Yaltik/hy
2
0
Fork 0
Code Pull Requests Releases Activity

Make HyKeyword a first class objects

Browse Source 
HyKeywords are no longer an instances of string with a particular
prefix, but a completely separate object.

This means keywords no longer trip isinstance str checks, adding a
little bit of type safety to the compiler.

It also means that HyKeywords evaluate to themselves.

Closes #1352
This commit is contained in:
Simon Gomizelj 2018-02-09 22:56:33 -05:00 committed by Kodi Arfer
parent 2ad3401b36
commit 1b7dfd2839
6 changed files with 73 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
hy/compiler.py
View File

@ -500,19 +500,18 @@ class HyASTCompiler(object):
except StopIteration:
raise HyTypeError(expr,
"Keyword argument {kw} needs "
"a value.".format(kw=str(expr[1:])))
"a value.".format(kw=expr))
if not expr:
raise HyTypeError(expr, "Can't call a function with the "
"empty keyword")
compiled_value = self.compile(value)
ret += compiled_value
keyword = expr[2:]
if not keyword:
raise HyTypeError(expr, "Can't call a function with the "
"empty keyword")
keyword = ast_str(keyword)
arg = str_type(expr)[1:]
keywords.append(asty.keyword(
expr, arg=keyword, value=compiled_value.force_expr))
expr, arg=ast_str(arg), value=compiled_value.force_expr))
else:
ret += self.compile(expr)
@ -742,6 +741,9 @@ class HyASTCompiler(object):
return imports, HyExpression([HySymbol(name),
HyString(form)]).replace(form), False
elif isinstance(form, HyKeyword):
return imports, form, False
elif isinstance(form, HyString):
x = [HySymbol(name), form]
if form.brackets is not None:
@ -1168,7 +1170,7 @@ class HyASTCompiler(object):
if isinstance(iexpr, HyList) and iexpr:
module = iexpr.pop(0)
entry = iexpr[0]
if isinstance(entry, HyKeyword) and entry == HyKeyword(":as"):
if entry == HyKeyword(":as"):
if not len(iexpr) == 2:
raise HyTypeError(iexpr,
"garbage after aliased import")
@ -1764,7 +1766,7 @@ class HyASTCompiler(object):
# An exception for pulling together keyword args is if we're doing
# a typecheck, eg (type :foo)
with_kwargs = fn not in (
"type", "HyKeyword", "keyword", "name", "keyword?")
"type", "HyKeyword", "keyword", "name", "keyword?", "identity")
args, ret, keywords, oldpy_star, oldpy_kw = self._compile_collect(
expression[1:], with_kwargs, oldpy_unpack=True)
@ -2187,7 +2189,18 @@ class HyASTCompiler(object):
return asty.Name(symbol, id=ast_str(symbol), ctx=ast.Load())
@builds(HyString, HyKeyword, HyBytes)
@builds(HyKeyword)
def compile_keyword(self, string):
ret = Result()
ret += asty.Call(
string,
func=asty.Name(string, id="HyKeyword", ctx=ast.Load()),
args=[asty.Str(string, s=str_type(string))],
keywords=[])
ret.add_imports("hy", {"HyKeyword"})
return ret
@builds(HyString, HyBytes)
def compile_string(self, string, building):
node = asty.Bytes if PY3 and building is HyBytes else asty.Str
f = bytes_type if building is HyBytes else str_type

8
hy/contrib/hy_repr.hy
View File

@ -32,7 +32,7 @@
(global -quoting)
(setv started-quoting False)
(when (and (not -quoting) (instance? HyObject obj))
(when (and (not -quoting) (instance? HyObject obj) (not (instance? HyKeyword obj)))
(setv -quoting True)
(setv started-quoting True))
@ -82,10 +82,8 @@
(+ (get syntax (first x)) (hy-repr (second x)))
(+ "(" (-cat x) ")"))))
(hy-repr-register HySymbol str)
(hy-repr-register [str-type bytes-type HyKeyword] (fn [x]
(if (and (instance? str-type x) (.startswith x HyKeyword.PREFIX))
(return (cut x 1)))
(hy-repr-register [HySymbol HyKeyword] str)
(hy-repr-register [str-type bytes-type] (fn [x]
(setv r (.lstrip (-base-repr x) "ub"))
(+
(if (instance? bytes-type x) "b" "")

31
hy/core/language.hy
View File

@ -65,8 +65,7 @@
(defn keyword? [k]
"Check whether `k` is a keyword."
(and (instance? (type :foo) k)
(.startswith k (get :foo 0))))
(instance? HyKeyword k))
(defn dec [n]
"Decrement `n` by 1."
@ -460,26 +459,26 @@ as EOF (defaults to an empty string)."
"Create a keyword from `value`.
Strings numbers and even objects with the __name__ magic will work."
(if (and (string? value) (value.startswith HyKeyword.PREFIX))
(unmangle value)
(if (string? value)
(HyKeyword (+ ":" (unmangle value)))
(try
(unmangle (.__name__ value))
(except [] (HyKeyword (+ ":" (string value))))))))
(if (keyword? value)
(HyKeyword (unmangle value))
(if (string? value)
(HyKeyword (unmangle value))
(try
(unmangle (.__name__ value))
(except [] (HyKeyword (string value)))))))
(defn name [value]
"Convert `value` to a string.
Keyword special character will be stripped. String will be used as is.
Even objects with the __name__ magic will work."
(if (and (string? value) (value.startswith HyKeyword.PREFIX))
(unmangle (cut value 2))
(if (string? value)
(unmangle value)
(try
(unmangle (. value __name__))
(except [] (string value))))))
(if (keyword? value)
(unmangle (cut (str value) 1))
(if (string? value)
(unmangle value)
(try
(unmangle (. value __name__))
(except [] (string value))))))
(defn xor [a b]
"Perform exclusive or between `a` and `b`."

39
hy/models.py
View File

@ -121,22 +121,37 @@ _wrappers[bool] = lambda x: HySymbol("True") if x else HySymbol("False")
_wrappers[type(None)] = lambda foo: HySymbol("None")
class HyKeyword(HyObject, str_type):
"""Generic Hy Keyword object. It's either a ``str`` or a ``unicode``,
depending on the Python version.
"""
class HyKeyword(HyObject):
"""Generic Hy Keyword object."""
PREFIX = "\uFDD0"
__slots__ = ['_value']
def __new__(cls, value):
if not value.startswith(cls.PREFIX):
value = cls.PREFIX + value
obj = str_type.__new__(cls, value)
return obj
def __init__(self, value):
if value[0] != ':':
value = ':' + value
self._value = value
def __repr__(self):
return "%s(%s)" % (self.__class__.__name__, repr(self[1:]))
return "%s(%r)" % (self.__class__.__name__, self._value)
def __str__(self):
return self._value
def __hash__(self):
return hash(self._value)
def __eq__(self, other):
if not isinstance(other, HyKeyword):
return NotImplemented
return self._value == other._value
def __ne__(self, other):
if not isinstance(other, HyKeyword):
return NotImplemented
return self._value != other._value
def __bool__(self):
return bool(self._value[1:])
def strip_digit_separators(number):

8
tests/native_tests/contrib/hy_repr.hy
View File

@ -79,14 +79,6 @@
(assert (is (type (get orig 1)) float))
(assert (is (type (get result 1)) HyFloat)))
(when PY3 (defn test-bytes-keywords []
; Make sure that keyword-like bytes objects aren't hy-repred as if
; they were real keywords.
(setv kw :mykeyword)
(assert (= (hy-repr kw) ":mykeyword"))
(assert (= (hy-repr (str ':mykeyword)) ":mykeyword"))
(assert (= (hy-repr (.encode kw "UTF-8") #[[b"\xef\xb7\x90:hello"]])))))
(when PY3 (defn test-dict-views []
(assert (= (hy-repr (.keys {1 2})) "(dict-keys [1])"))
(assert (= (hy-repr (.values {1 2})) "(dict-values [2])"))

10
tests/native_tests/language.hy
View File

@ -554,7 +554,7 @@
(assert (= (.a.b.meth :b "1" :a "2" x "foo" "bar") "meth foo bar 2 1"))
(assert (= (.a.b.meth x #* ["foo" "bar"]) "meth foo bar"))
(assert (is (.isdigit :foo) False)))
(assert (= (.__str__ :foo) ":foo")))
(defn test-do []
@ -1221,9 +1221,12 @@
"NATIVE: test if keywords are recognised"
(assert (= :foo :foo))
(assert (= :foo ':foo))
(assert (is (type :foo) (type ':foo)))
(assert (= (get {:foo "bar"} :foo) "bar"))
(assert (= (get {:bar "quux"} (get {:foo :bar} :foo)) "quux")))
(defn test-keyword-clash []
"NATIVE: test that keywords do not clash with normal strings"
@ -1649,11 +1652,6 @@ macros()
(setv (. foo [1] test) "hello")
(assert (= (getattr (. foo [1]) "test") "hello")))
(defn test-keyword-quoting []
"NATIVE: test keyword quoting magic"
(assert (= :foo "\ufdd0:foo"))
(assert (= `:foo "\ufdd0:foo")))
(defn test-only-parse-lambda-list-in-defn []
"NATIVE: test lambda lists are only parsed in defn"
(try