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

Merge pull request #1789 from Kodiologist/rm-defclass-attr-list

Browse Source 
Remove the attribute list of `defclass`
This commit is contained in:
Kodi Arfer 2019-07-17 14:40:13 -04:00 committed by GitHub
commit 1b1a6d7684
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 143 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
NEWS.rst
View File

@ -6,6 +6,8 @@ Unreleased
Removals
------------------------------
* Python 2 is no longer supported.
* Support for attribute lists in `defclass` has been removed. Use `setv`
and `defn` instead.
0.17.0
==============================

4
docs/contrib/hy_repr.rst
View File

@ -67,8 +67,8 @@ your choice to the keyword argument ``:placeholder`` of
.. code-block:: hy
(defclass Container [object]
[__init__ (fn [self value]
(setv self.value value))])
(defn __init__ (fn [self value]
(setv self.value value))))
(hy-repr-register Container :placeholder "HY THERE" (fn [x]
(+ "(Container " (hy-repr x.value) ")")))
(setv container (Container 5))

14
docs/language/api.rst
View File

@ -430,16 +430,16 @@ Whereas ``setv`` creates an assignment statement, ``setx`` creates an assignment
defclass
--------
New classes are declared with ``defclass``. It can take three optional parameters in the following order:
a list defining (a) possible super class(es), a string (:term:`py:docstring`) and another list containing
attributes of the new class along with their corresponding values.
New classes are declared with ``defclass``. It can take optional parameters in the following order:
a list defining (a) possible super class(es) and a string (:term:`py:docstring`).
.. code-block:: clj
(defclass class-name [super-class-1 super-class-2]
"docstring"
[attribute1 value1
attribute2 value2]
(setv attribute1 value1)
(setv attribute2 value2)
(defn method [self] (print "hello!")))
@ -449,8 +449,8 @@ below:
.. code-block:: clj
=> (defclass Cat []
... [age None
... colour "white"]
... (setv age None)
... (setv colour "white")
...
... (defn speak [self] (print "Meow")))

6
docs/tutorial.rst
View File

@ -527,9 +527,9 @@ In Hy:
.. code-block:: clj
(defclass Customer [models.Model]
[name (models.CharField :max-length 255)
address (models.TextField)
notes (models.TextField)])
(setv name (models.CharField :max-length 255))
(setv address (models.TextField))
(setv notes (models.TextField)))
Macros
======

10
hy/compiler.py
View File

@ -1475,10 +1475,9 @@ class HyASTCompiler(object):
@special("defclass", [
SYM,
maybe(brackets(many(FORM)) + maybe(STR) +
maybe(brackets(many(SYM + FORM))) + many(FORM))])
maybe(brackets(many(FORM)) + maybe(STR) + many(FORM))])
def compile_class_expression(self, expr, root, name, rest):
base_list, docstring, attrs, body = rest or ([[]], None, None, [])
base_list, docstring, body = rest or ([[]], None, [])
bases_expr, bases, keywords = (
self._compile_collect(base_list[0], with_kwargs=True))
@ -1488,11 +1487,6 @@ class HyASTCompiler(object):
if docstring is not None:
bodyr += self.compile(docstring).expr_as_stmt()
if attrs is not None:
bodyr += self.compile(self._rewire_init(HyExpression(
[HySymbol("setv")] +
[x for pair in attrs[0] for x in pair]).replace(attrs)))
for e in body:
e = self.compile(self._rewire_init(
macroexpand(e, self.module, self)))

12
hy/contrib/multi.hy
View File

@ -6,11 +6,11 @@
(import [collections [defaultdict]]
[hy [HyExpression HyList HyString]])
(defclass MultiDispatch [object] [
(defclass MultiDispatch [object]
_fns (defaultdict dict)
(setv _fns (defaultdict dict))
__init__ (fn [self f]
(defn __init__ [self f]
(setv self.f f)
(setv self.__doc__ f.__doc__)
(unless (in f.__name__ (.keys (get self._fns f.__module__)))
@ -18,14 +18,14 @@
(setv values f.__code__.co_varnames)
(setv (get self._fns f.__module__ f.__name__ values) f))
fn? (fn [self v args kwargs]
(defn fn? [self v args kwargs]
"Compare the given (checked fn) to the called fn"
(setv com (+ (list args) (list (.keys kwargs))))
(and
(= (len com) (len v))
(.issubset (frozenset (.keys kwargs)) com)))
__call__ (fn [self &rest args &kwargs kwargs]
(defn __call__ [self &rest args &kwargs kwargs]
(setv func None)
(for [[i f] (.items (get self._fns self.f.__module__ self.f.__name__))]
(when (.fn? self i args kwargs)
@ -33,7 +33,7 @@
(break)))
(if func
(func #* args #** kwargs)
(raise (TypeError "No matching functions with this signature"))))])
(raise (TypeError "No matching functions with this signature")))))
(defn multi-decorator [dispatch-fn]
(setv inner (fn [&rest args &kwargs kwargs]

101
hy/contrib/sequences.hy
View File

@ -3,53 +3,60 @@
;; license. See the LICENSE.
(defclass Sequence []
[--init-- (fn [self func]
"initialize a new sequence with a function to compute values"
(setv (. self func) func)
(setv (. self cache) [])
(setv (. self high-water) -1))
--getitem-- (fn [self n]
"get nth item of sequence"
(if (hasattr n "start")
(gfor x (range n.start n.stop (or n.step 1))
(get self x))
(do (when (neg? n)
; Call (len) to force the whole
; sequence to be evaluated.
(len self))
(if (<= n (. self high-water))
(get (. self cache) n)
(do (while (< (. self high-water) n)
(setv (. self high-water) (inc (. self high-water)))
(.append (. self cache) (.func self (. self high-water))))
(get self n))))))
--iter-- (fn [self]
"create iterator for this sequence"
(setv index 0)
(try (while True
(yield (get self index))
(setv index (inc index)))
(except [IndexError]
(return))))
--len-- (fn [self]
"length of the sequence, dangerous for infinite sequences"
(setv index (. self high-water))
(try (while True
(get self index)
(setv index (inc index)))
(except [IndexError]
(len (. self cache)))))
max-items-in-repr 10
--str-- (fn [self]
"string representation of this sequence"
(setv items (list (take (inc self.max-items-in-repr) self)))
(.format (if (> (len items) self.max-items-in-repr)
"[{0}, ...]"
"[{0}]")
(.join ", " (map str items))))
--repr-- (fn [self]
"string representation of this sequence"
(.--str-- self))])
(defn --init-- [self func]
"initialize a new sequence with a function to compute values"
(setv (. self func) func)
(setv (. self cache) [])
(setv (. self high-water) -1))
(defn --getitem-- [self n]
"get nth item of sequence"
(if (hasattr n "start")
(gfor x (range n.start n.stop (or n.step 1))
(get self x))
(do (when (neg? n)
; Call (len) to force the whole
; sequence to be evaluated.
(len self))
(if (<= n (. self high-water))
(get (. self cache) n)
(do (while (< (. self high-water) n)
(setv (. self high-water) (inc (. self high-water)))
(.append (. self cache) (.func self (. self high-water))))
(get self n))))))
(defn --iter-- [self]
"create iterator for this sequence"
(setv index 0)
(try (while True
(yield (get self index))
(setv index (inc index)))
(except [IndexError]
(return))))
(defn --len-- [self]
"length of the sequence, dangerous for infinite sequences"
(setv index (. self high-water))
(try (while True
(get self index)
(setv index (inc index)))
(except [IndexError]
(len (. self cache)))))
(setv max-items-in-repr 10)
(defn --str-- [self]
"string representation of this sequence"
(setv items (list (take (inc self.max-items-in-repr) self)))
(.format (if (> (len items) self.max-items-in-repr)
"[{0}, ...]"
"[{0}]")
(.join ", " (map str items))))
(defn --repr-- [self]
"string representation of this sequence"
(.--str-- self)))
(defmacro seq [param &rest seq-code]
`(Sequence (fn ~param (do ~@seq-code))))

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

@ -158,8 +158,8 @@
(assert (= (hy-repr (C)) "cuddles"))
(defclass Container [object]
[__init__ (fn [self value]
(setv self.value value))])
(defn __init__ [self value]
(setv self.value value)))
(hy-repr-register Container :placeholder "(Container ...)" (fn [x]
(+ "(Container " (hy-repr x.value) ")")))
(setv container (Container 5))
@ -170,5 +170,5 @@
(defn test-hy-repr-fallback []
(defclass D [object]
[__repr__ (fn [self] "cuddles")])
(defn __repr__ [self] "cuddles"))
(assert (= (hy-repr (D)) "cuddles")))

2
tests/native_tests/core.hy
View File

@ -300,7 +300,7 @@ result['y in globals'] = 'y' in globals()")
(assert-requires-num inc)
(defclass X [object]
[__add__ (fn [self other] (.format "__add__ got {}" other))])
(defn __add__ [self other] (.format "__add__ got {}" other)))
(assert-equal (inc (X)) "__add__ got 1"))
(defn test-instance []

28
tests/native_tests/defclass.hy
View File

@ -27,7 +27,7 @@
(defn test-defclass-attrs []
"NATIVE: test defclass attributes"
(defclass A []
[x 42])
(setv x 42))
(assert (= A.x 42))
(assert (= (getattr (A) "x") 42)))
@ -35,9 +35,9 @@
(defn test-defclass-attrs-fn []
"NATIVE: test defclass attributes with fn"
(defclass B []
[x 42
y (fn [self value]
(+ self.x value))])
(setv x 42)
(setv y (fn [self value]
(+ self.x value))))
(assert (= B.x 42))
(assert (= (.y (B) 5) 47))
(setv b (B))
@ -48,17 +48,17 @@
(defn test-defclass-dynamic-inheritance []
"NATIVE: test defclass with dynamic inheritance"
(defclass A [((fn [] (if True list dict)))]
[x 42])
(setv x 42))
(assert (isinstance (A) list))
(defclass A [((fn [] (if False list dict)))]
[x 42])
(setv x 42))
(assert (isinstance (A) dict)))
(defn test-defclass-no-fn-leak []
"NATIVE: test defclass attributes with fn"
(defclass A []
[x (fn [] 1)])
(setv x (fn [] 1)))
(try
(do
(x)
@ -68,13 +68,13 @@
(defn test-defclass-docstring []
"NATIVE: test defclass docstring"
(defclass A []
[--doc-- "doc string"
x 1])
(setv --doc-- "doc string")
(setv x 1))
(setv a (A))
(assert (= a.__doc__ "doc string"))
(defclass B []
"doc string"
[x 1])
(setv x 1))
(setv b (B))
(assert (= b.x 1))
(assert (= b.__doc__ "doc string"))
@ -82,7 +82,7 @@
"begin a very long multi-line string to make
sure that it comes out the way we hope
and can span 3 lines end."
[x 1])
(setv x 1))
(setv mL (MultiLine))
(assert (= mL.x 1))
(assert (in "begin" mL.__doc__))
@ -100,8 +100,8 @@
"NATIVE: test defclass syntax with properties and methods and side-effects"
(setv foo 1)
(defclass A []
[x 1
y 2]
(setv x 1)
(setv y 2)
(global foo)
(setv foo 2)
(defn greet [self]
@ -117,7 +117,7 @@
(defn test-defclass-implicit-none-for-init []
"NATIVE: test that defclass adds an implicit None to --init--"
(defclass A []
[--init-- (fn [self] (setv self.x 1) 42)])
(setv --init-- (fn [self] (setv self.x 1) 42)))
(defclass B []
(defn --init-- [self]
(setv self.x 2)

36
tests/native_tests/language.hy
View File

@ -129,8 +129,8 @@
(assert (none? (setv (get {} "x") 42)))
(setv l [])
(defclass Foo [object]
[__setattr__ (fn [self attr val]
(.append l [attr val]))])
(defn __setattr__ [self attr val]
(.append l [attr val])))
(setv x (Foo))
(assert (none? (setv x.eggs "ham")))
(assert (not (hasattr x "eggs")))
@ -443,9 +443,9 @@
(defclass X [object] [])
(defclass M [object]
[meth (fn [self &rest args &kwargs kwargs]
(defn meth [self &rest args &kwargs kwargs]
(.join " " (+ (, "meth") args
(tuple (map (fn [k] (get kwargs k)) (sorted (.keys kwargs)))))))])
(tuple (map (fn [k] (get kwargs k)) (sorted (.keys kwargs))))))))
(setv x (X))
(setv m (M))
@ -1667,7 +1667,7 @@ macros()
(defn test-underscore_variables []
; https://github.com/hylang/hy/issues/1340
(defclass XYZ []
[_42 6])
(setv _42 6))
(setv x (XYZ))
(assert (= (. x _42) 6)))
@ -1773,24 +1773,26 @@ macros()
(defn test-pep-3115 []
(defclass member-table [dict]
[--init-- (fn [self] (setv self.member-names []))
(defn --init-- [self]
(setv self.member-names []))
--setitem-- (fn [self key value]
(if (not-in key self)
(.append self.member-names key))
(dict.--setitem-- self key value))])
(defn --setitem-- [self key value]
(if (not-in key self)
(.append self.member-names key))
(dict.--setitem-- self key value)))
(defclass OrderedClass [type]
[--prepare-- (classmethod (fn [metacls name bases] (member-table)))
(setv --prepare-- (classmethod (fn [metacls name bases]
(member-table))))
--new-- (fn [cls name bases classdict]
(setv result (type.--new-- cls name bases (dict classdict)))
(setv result.member-names classdict.member-names)
result)])
(defn --new-- [cls name bases classdict]
(setv result (type.--new-- cls name bases (dict classdict)))
(setv result.member-names classdict.member-names)
result))
(defclass MyClass [:metaclass OrderedClass]
[method1 (fn [self] (pass))
method2 (fn [self] (pass))])
(defn method1 [self] (pass))
(defn method2 [self] (pass)))
(assert (= (. (MyClass) member-names)
["__module__" "__qualname__" "method1" "method2"])))

31
tests/native_tests/mathematics.hy
View File

@ -34,7 +34,7 @@
"NATIVE: test that unary + calls __pos__"
(defclass X [object]
[__pos__ (fn [self] "called __pos__")])
(defn __pos__ [self] "called __pos__"))
(assert (= (+ (X)) "called __pos__"))
; Make sure the shadowed version works, too.
@ -159,21 +159,20 @@
(defclass HyTestMatrix [list]
[--matmul--
(fn [self other]
(setv n (len self)
m (len (. other [0]))
result [])
(for [i (range m)]
(setv result-row [])
(for [j (range n)]
(setv dot-product 0)
(for [k (range (len (. self [0])))]
(+= dot-product (* (. self [i] [k])
(. other [k] [j]))))
(.append result-row dot-product))
(.append result result-row))
result)])
(defn --matmul-- [self other]
(setv n (len self)
m (len (. other [0]))
result [])
(for [i (range m)]
(setv result-row [])
(for [j (range n)]
(setv dot-product 0)
(for [k (range (len (. self [0])))]
(+= dot-product (* (. self [i] [k])
(. other [k] [j]))))
(.append result-row dot-product))
(.append result result-row))
result))
(setv first-test-matrix (HyTestMatrix [[1 2 3]
[4 5 6]

16
tests/native_tests/operators.hy
View File

@ -34,7 +34,7 @@
(assert (= (f) 0))
(defclass C [object] [__pos__ (fn [self] "called __pos__")])
(defclass C [object] (defn __pos__ [self] "called __pos__"))
(assert (= (f (C)) "called __pos__"))
(assert (= (f 1 2) 3))
@ -101,9 +101,9 @@
(op-and-shadow-test @
(defclass C [object] [
__init__ (fn [self content] (setv self.content content))
__matmul__ (fn [self other] (C (+ self.content other.content)))])
(defclass C [object]
(defn __init__ [self content] (setv self.content content))
(defn __matmul__ [self other] (C (+ self.content other.content))))
(forbid (f))
(assert (do (setv c (C "a")) (is (f c) c)))
(assert (= (. (f (C "b") (C "c")) content) "bc"))
@ -171,11 +171,11 @@
; Make sure chained comparisons use `and`, not `&`.
; https://github.com/hylang/hy/issues/1191
(defclass C [object] [
__init__ (fn [self x]
(defclass C [object]
(defn __init__ [self x]
(setv self.x x))
__lt__ (fn [self other]
self.x)])
(defn __lt__ [self other]
self.x))
(assert (= (f (C "a") (C "b") (C "c")) "b")))

4
tests/native_tests/py36_only_tests.hy
View File

@ -40,8 +40,8 @@
(defn test-pep-487 []
(defclass QuestBase []
[--init-subclass-- (fn [cls swallow &kwargs kwargs]
(setv cls.swallow swallow))])
(defn --init-subclass-- [cls swallow &kwargs kwargs]
(setv cls.swallow swallow)))
(defclass Quest [QuestBase :swallow "african"])
(assert (= (. (Quest) swallow) "african")))

2
tests/native_tests/with_decorator.hy
View File

@ -27,7 +27,7 @@
cls)
(with-decorator bardec
(defclass cls []
[attr1 123]))
(setv attr1 123)))
(assert (= cls.attr1 123))
(assert (= cls.attr2 456)))

6
tests/resources/pydemo.hy
View File

@ -142,13 +142,13 @@ Call me Ishmael. Some years ago—never mind how long precisely—having little
(defclass C2 [C1]
"class docstring"
[attr1 5 attr2 6]
(setv attr3 7))
(setv attr1 5)
(setv attr2 6))
(import [contextlib [closing]])
(setv closed [])
(defclass Closeable []
[close (fn [self] (.append closed self.x))])
(defn close [self] (.append closed self.x)))
(with [c1 (closing (Closeable)) c2 (closing (Closeable))]
(setv c1.x "v1")
(setv c2.x "v2"))

2
tests/test_hy2py.py
View File

@ -113,7 +113,7 @@ def assert_stuff(m):
assert m.C2.__doc__ == "class docstring"
assert issubclass(m.C2, m.C1)
assert (m.C2.attr1, m.C2.attr2, m.C2.attr3) == (5, 6, 7)
assert (m.C2.attr1, m.C2.attr2) == (5, 6)
assert m.closed == ["v2", "v1"]