Merge branch 'master' into pr/1135

hy/compiler.py

@@ -503,19 +503,13 @@ class HyASTCompiler(object):
         for expr in exprs:
 
             if expr in ll_keywords:
-                if expr == "&rest" and lambda_keyword is None:
+                if expr == "&optional":
-                    lambda_keyword = expr
-                elif expr == "&optional":
                     if len(defaults) > 0:
                         raise HyTypeError(expr,
                                           "There can only be &optional "
                                           "arguments or one &key argument")
                     lambda_keyword = expr
-                elif expr == "&key":
+                elif expr in ("&rest", "&key", "&kwonly", "&kwargs"):
-                    lambda_keyword = expr
-                elif expr == "&kwonly":
-                    lambda_keyword = expr
-                elif expr == "&kwargs":
                     lambda_keyword = expr
                 else:
                     raise HyTypeError(expr,

hy/core/language.hy

@@ -39,10 +39,6 @@
 (import [hy.lex [LexException PrematureEndOfInput tokenize]])
 (import [hy.compiler [HyASTCompiler]])
 
-(defn _numeric-check [x]
-  (if (not (numeric? x))
-    (raise (TypeError (.format "{0!r} is not a number" x)))))
-
 (defn butlast [coll]
   "Returns coll except of last element."
   (drop-last 1 coll))
@@ -66,7 +62,6 @@
 
 (defn dec [n]
   "Decrement n by 1"
-  (_numeric-check n)
   (- n 1))
 
 (defn disassemble [tree &optional [codegen false]]
@@ -170,7 +165,6 @@
 
 (defn even? [n]
   "Return true if n is an even number"
-  (_numeric-check n)
   (= (% n 2) 0))
 
 (defn every? [pred coll]
@@ -239,7 +233,6 @@
 
 (defn inc [n]
   "Increment n by 1"
-  (_numeric-check n)
   (+ n 1))
 
 (defn instance? [klass x]
@@ -325,7 +318,6 @@
 
 (defn neg? [n]
   "Return true if n is < 0"
-  (_numeric-check n)
   (< n 0))
 
 (defn none? [x]
@@ -347,7 +339,6 @@
 
 (defn odd? [n]
   "Return true if n is an odd number"
-  (_numeric-check n)
   (= (% n 2) 1))
 
 (def -sentinel (object))
@@ -364,7 +355,6 @@
 
 (defn pos? [n]
   "Return true if n is > 0"
-  (_numeric_check n)
   (> n 0))
 
 (defn rest [coll]
@@ -415,7 +405,6 @@
 
 (defn zero? [n]
   "Return true if n is 0"
-  (_numeric_check n)
   (= n 0))
 
 (defn read [&optional [from-file sys.stdin]

hy/core/macros.hy

@@ -30,6 +30,16 @@
         [hy.models.symbol [HySymbol]]
         [hy._compat [PY33 PY34]])
 
+(defmacro as-> [head name &rest rest]
+  "Expands to sequence of assignments to the provided name, starting with head.
+  The previous result is thus available in the subsequent form. Returns the
+  final result, and leaves the name bound to it in the local scope. This behaves
+  much like the other threading macros, but requires you to specify the threading
+  point per form via the name instead of always the first or last arument."
+  `(do (setv
+         ~name ~head
+         ~@(interleave (repeat name) rest))
+     ~name))
 
 (defmacro with [args &rest body]
   "shorthand for nested with* loops:

hy/importer.py

@@ -89,6 +89,15 @@ def import_file_to_module(module_name, fpath):
     return mod
 
 
+def import_file_to_globals(env, module_name, fpath):
+    """ Import content from fpath and puts it into the dict provided
+    (e.g., for use in a REPL)
+    """
+    mod = import_file_to_module(module_name, fpath)
+    for k, v in mod.__dict__.items():
+        env[k] = v
+
+
 def import_buffer_to_module(module_name, buf):
     try:
         _ast = import_buffer_to_ast(buf, module_name)

tests/compilers/test_ast.py

@@ -397,6 +397,7 @@ def test_lambda_list_keywords_rest():
     """ Ensure we can compile functions with lambda list keywords."""
     can_compile("(fn (x &rest xs) (print xs))")
     cant_compile("(fn (x &rest xs &rest ys) (print xs))")
+    can_compile("(fn (&optional a &rest xs) (print xs))")
 
 
 def test_lambda_list_keywords_key():
@@ -410,6 +411,7 @@ def test_lambda_list_keywords_kwargs():
     """ Ensure we can compile functions with &kwargs."""
     can_compile("(fn (x &kwargs kw) (list x kw))")
     cant_compile("(fn (x &kwargs xs &kwargs ys) (list x xs ys))")
+    can_compile("(fn (&optional x &kwargs kw) (list x kw))")
 
 
 def test_lambda_list_keywords_kwonly():

tests/native_tests/core.hy

@@ -19,6 +19,8 @@
 ;; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 ;; DEALINGS IN THE SOFTWARE.
 
+(import [hy._compat [PY3]])
+
 ;;;; some simple helpers
 
 (defn assert-true [x]
@@ -33,6 +35,12 @@
 (defn assert-nil [x]
   (assert (is x nil)))
 
+(defn assert-requires-num [f]
+  (for [x ["foo" [] None]]
+    (try (f x)
+         (except [TypeError] True)
+         (else (assert False)))))
+
 (defn test-coll? []
   "NATIVE: testing coll?"
   (assert-true (coll? [1 2 3]))
@@ -66,12 +74,7 @@
   (assert-equal 0 (dec 1))
   (assert-equal -1 (dec 0))
   (assert-equal 0 (dec (dec 2)))
-  (try (do (dec "foo") (assert False))
+  (assert-requires-num dec))
-       (except [e [TypeError]] (assert (in "not a number" (str e)))))
-  (try (do (dec []) (assert False))
-       (except [e [TypeError]] (assert (in "not a number" (str e)))))
-  (try (do (dec None) (assert False))
-       (except [e [TypeError]] (assert (in "not a number" (str e))))))
 
 (defn test-setv []
   "NATIVE: testing setv mutation"
@@ -173,12 +176,7 @@
   (assert-true (even? -2))
   (assert-false (even? 1))
   (assert-true (even? 0))
-  (try (even? "foo")
+  (assert-requires-num even?))
-       (except [e [TypeError]] (assert (in "not a number" (str e)))))
-  (try (even? [])
-       (except [e [TypeError]] (assert (in "not a number" (str e)))))
-  (try (even? None)
-       (except [e [TypeError]] (assert (in "not a number" (str e))))))
 
 (defn test-every? []
   "NATIVE: testing the every? function"
@@ -263,12 +261,11 @@
   "NATIVE: testing the inc function"
   (assert-equal 3 (inc 2))
   (assert-equal 0 (inc -1))
-  (try (do (inc "foo") (assert False))
+  (assert-requires-num inc)
-       (except [e [TypeError]] (assert (in "not a number" (str e)))))
+
-  (try (do (inc []) (assert False))
+  (defclass X [object]
-       (except [e [TypeError]] (assert (in "not a number" (str e)))))
+    [__add__ (fn [self other] (.format "__add__ got {}" other))])
-  (try (do (inc None) (assert False))
+  (assert-equal (inc (X)) "__add__ got 1"))
-       (except [e [TypeError]] (assert (in "not a number" (str e))))))
 
 (defn test-instance []
   "NATIVE: testing instance? function"
@@ -394,24 +391,14 @@
   (assert-true (neg? -2))
   (assert-false (neg? 1))
   (assert-false (neg? 0))
-  (try (do (neg? "foo") (assert False))
+  (when PY3
-       (except [e [TypeError]] (assert (in "not a number" (str e)))))
+    (assert-requires-num neg?)))
-  (try (do (neg? []) (assert False))
-       (except [e [TypeError]] (assert (in "not a number" (str e)))))
-  (try (do (neg? None) (assert False))
-       (except [e [TypeError]] (assert (in "not a number" (str e))))))
 
 (defn test-zero []
   "NATIVE: testing the zero? function"
   (assert-false (zero? -2))
   (assert-false (zero? 1))
-  (assert-true (zero? 0))
+  (assert-true (zero? 0)))
-  (try (do (zero? "foo") (assert False))
-       (except [e [TypeError]] (assert (in "not a number" (str e)))))
-  (try (do (zero? []) (assert False))
-       (except [e [TypeError]] (assert (in "not a number" (str e)))))
-  (try (do (zero? None) (assert False))
-       (except [e [TypeError]] (assert (in "not a number" (str e))))))
 
 (defn test-none []
   "NATIVE: testing for `is None`"
@@ -463,12 +450,7 @@
   (assert-true (odd? -3))
   (assert-true (odd? 1))
   (assert-false (odd? 0))
-  (try (do (odd? "foo") (assert False))
+  (assert-requires-num odd?))
-       (except [e [TypeError]] (assert (in "not a number" (str e)))))
-  (try (do (odd? []) (assert False))
-       (except [e [TypeError]] (assert (in "not a number" (str e)))))
-  (try (do (odd? None) (assert False))
-       (except [e [TypeError]] (assert (in "not a number" (str e))))))
 
 (defn test-partition []
   "NATIVE: testing the partition function"
@@ -500,12 +482,8 @@
   (assert-true (pos? 2))
   (assert-false (pos? -1))
   (assert-false (pos? 0))
-  (try (do (pos? "foo") (assert False))
+  (when PY3
-       (except [e [TypeError]] (assert (in "not a number" (str e)))))
+    (assert-requires-num pos?)))
-  (try (do (pos? []) (assert False))
-       (except [e [TypeError]] (assert (in "not a number" (str e)))))
-  (try (do (pos? None) (assert False))
-       (except [e [TypeError]] (assert (in "not a number" (str e))))))
 
 (defn test-remove []
   "NATIVE: testing the remove function"