allowing foo-bar

hy/compiler.py

@@ -159,8 +159,8 @@ class HyASTCompiler(object):
     @builds(">=")
     @builds("is")
     @builds("in")
-    @builds("is-not")
-    @builds("not-in")
+    @builds("is_not")
+    @builds("not_in")
     def compile_compare_op_expression(self, expression):
         ops = {"=": ast.Eq,
                "!=": ast.NotEq,
@@ -169,9 +169,9 @@ class HyASTCompiler(object):
                ">": ast.Gt,
                ">=": ast.GtE,
                "is": ast.Is,
-               "is-not": ast.IsNot,
+               "is_not": ast.IsNot,
                "in": ast.In,
-               "not-in": ast.NotIn}
+               "not_in": ast.NotIn}
 
         inv = expression.pop(0)
         op = ops[inv]

hy/lex/states.py

@@ -60,6 +60,9 @@ def _resolve_atom(obj):
     if obj in table:
         return HySymbol(table[obj])
 
+    if "-" in obj and obj != "-":
+        obj = obj.replace("-", "_")
+
     return HySymbol(obj)
 
 

tests/native_tests/language.hy

@@ -1,12 +1,12 @@
 ;
 
 
-(defn test_lists []
+(defn test-lists []
   "NATIVE: test lists work right"
   (assert (= [1 2 3 4] (+ [1 2] [3 4]))))
 
 
-(defn test_for_loop []
+(defn test-for-loop []
   "NATIVE: test for loops?"
   (def count 0)
   (for [x [1 2 3 4 5]]
@@ -14,18 +14,18 @@
   (assert (= count 15)))
 
 
-(defn test_in []
+(defn test-in []
   "NATIVE: test in"
   (assert (in "a" ["a" "b" "c" "d"]))
   (assert (not-in "f" ["a" "b" "c" "d"])))
 
 
-(defn test_noteq []
+(defn test-noteq []
   "NATIVE: not eq"
   (assert (!= 2 3)))
 
 
-(defn test_numops []
+(defn test-numops []
   "NATIVE: test numpos"
   (assert (> 5 4 3 2 1))
   (assert (< 1 2 3 4 5))
@@ -33,21 +33,21 @@
   (assert (>= 5 5 5 5 )))
 
 
-(defn test_is []
+(defn test-is []
   "NATIVE: test is can deal with None"
   (def a null)
   (assert (is a null))
   (assert (is-not a "b")))
 
 
-(defn test_branching []
+(defn test-branching []
   "NATIVE: test if branching"
   (if true
     (assert (= 1 1))
     (assert (= 2 1))))
 
 
-(defn test_branching_with_do []
+(defn test-branching-with-do []
   "NATIVE: test if branching (multiline)"
   (if false
     (assert (= 2 1))
@@ -57,20 +57,20 @@
       (assert (= 1 1)))))
 
 
-(defn test_cond []
+(defn test-cond []
   "NATIVE: test if cond sorta works."
   (cond
     (= 1 2) (assert (= true false))
     (is null null) (assert (= true true))))
 
 
-(defn test_index []
+(defn test-index []
   "NATIVE: Test that dict access works"
   (assert (get {"one" "two"} "one") "two")
   (assert (= (get [1 2 3 4 5] 1) 2)))
 
 
-(defn test_lambda []
+(defn test-lambda []
   "NATIVE: test lambda operator"
   (def square (lambda [x] (* x x)))
   (assert (= 4 (square 2))))