rename lambda to fn

tests/test_eval.py

@@ -486,23 +486,23 @@ class EvalFunctionTest(OpTest):
     def test_lambda_args(self):
         '''Lambdas should raise errors for wrong arguments'''
         with self.assertRaises(WalEvalError):
-            self.w.eval_str('(lambda (x))')
+            self.w.eval_str('(fn (x))')
 
         with self.assertRaises(WalEvalError):
-            self.w.eval_str('(lambda (x 1) x)')
+            self.w.eval_str('(fn (x 1) x)')
 
     def test_lambda_apply(self):
         '''Lambdas should perform correct action if applied'''
 
         # Apply from inline definition
-        self.checkEqual('((lambda (x) (+ x 1)) 1)', 2)
+        self.checkEqual('((fn (x) (+ x 1)) 1)', 2)
 
         # correct number of args must be supplied
         # with self.assertRaises(WalEvalError):
         #     self.w.eval_str('(lambda (x) (+ x 1) 1 2)')
 
         # Apply named lambda
-        self.w.eval_str('(define foo (lambda (y) (* y 2)))')
+        self.w.eval_str('(define foo (fn (y) (* y 2)))')
         self.checkEqual('(foo 5)', 10)
 
 

tests/test_eval_list.py

@@ -74,7 +74,7 @@ def test_map(self):
         '''test map operator'''
         l1 = "'(1 2 3 4)"
         l2 = "'(\"a\" \"b\")"
-        f = '(lambda (x) (+ x 1))'
+        f = '(fn (x) (+ x 1))'
         self.checkEqual(f'(map {f} {l1})', [2, 3, 4, 5])
         self.checkEqual(f'(map {f} {l2})', ['a1', 'b1'])
 

tests/test_trace_eq.py

@@ -37,10 +37,10 @@ def test_goto_end(self):
         self.eval_eq("(do (while (step) 0) INDEX)")
 
     def test_ts_list(self):
-        self.eval_eq("(map (lambda [x] TS@x) (range MAX-INDEX))")
+        self.eval_eq("(map (fn [x] TS@x) (range MAX-INDEX))")
 
     def test_all_signal_values(self):
-        self.eval_eq("(map (lambda [x] (map get SIGNALS)@x) (range MAX-INDEX))")
+        self.eval_eq("(map (fn [x] (map get SIGNALS)@x) (range MAX-INDEX))")
 
 
 class CounterEqualTest(TraceEqTest, unittest.TestCase):

tests/test_varresolve.py

@@ -56,13 +56,13 @@ def test_undefined_symbol_should_stay_symbol(self):
         self.checkEqual('(define x x)', [Op.DEFINE, S('x'), S('x')])
 
     def test_lambda_resolution(self):
-        self.checkEqual('(lambda [x] x)', [Op.LAMBDA, [S('x')], S('x', 0)])
-        self.checkEqual('(lambda [x] y)', [Op.LAMBDA, [S('x')], S('y')])
-        self.checkEqual('(do (define y 5) (lambda [x] y))', [Op.DO, [Op.DEFINE, S('y'), 5], [Op.LAMBDA, [S('x')], S('y', 1)]])
-        self.checkEqual('(lambda [x] (lambda [y] x))', [Op.LAMBDA, [S('x')], [Op.LAMBDA, [S('y')], S('x', 1)]])
-        self.checkEqual('(lambda [x] (lambda [y] y))', [Op.LAMBDA, [S('x')], [Op.LAMBDA, [S('y')], S('y', 0)]])
-        self.checkEqual('(lambda [x y] (lambda [y] y))', [Op.LAMBDA, [S('x'), S('y')], [Op.LAMBDA, [S('y')], S('y', 0)]])
-        self.checkEqual('(lambda [x y] (lambda [z] y))', [Op.LAMBDA, [S('x'), S('y')], [Op.LAMBDA, [S('z')], S('y', 1)]])
+        self.checkEqual('(fn [x] x)', [Op.FN, [S('x')], S('x', 0)])
+        self.checkEqual('(fn [x] y)', [Op.FN, [S('x')], S('y')])
+        self.checkEqual('(do (define y 5) (fn [x] y))', [Op.DO, [Op.DEFINE, S('y'), 5], [Op.FN, [S('x')], S('y', 1)]])
+        self.checkEqual('(fn [x] (fn [y] x))', [Op.FN, [S('x')], [Op.FN, [S('y')], S('x', 1)]])
+        self.checkEqual('(fn [x] (fn [y] y))', [Op.FN, [S('x')], [Op.FN, [S('y')], S('y', 0)]])
+        self.checkEqual('(fn [x y] (fn [y] y))', [Op.FN, [S('x'), S('y')], [Op.FN, [S('y')], S('y', 0)]])
+        self.checkEqual('(fn [x y] (fn [z] y))', [Op.FN, [S('x'), S('y')], [Op.FN, [S('z')], S('y', 1)]])
 
     def test_resolution_in_set(self):
         self.checkEqual('(set [x 5])', [Op.SET, [S('x'), 5]])
@@ -118,12 +118,12 @@ def test_undefined_symbol_should_stay_symbol(self):
         self.checkRaises('(define x x)')
 
     def test_lambda_resolution(self):
-        self.checkEqual('((lambda [x] x) 5)', 5)
-        self.checkEqual('(do (define y 5) ((lambda [x] y) 2))', 5)
-        self.checkEqual('((lambda [x] ((lambda [y] x) 2)) 1)', 1)
-        self.checkEqual('((lambda [x] ((lambda [y] y) x)) 11)', 11)
-        self.checkEqual('((lambda [x y] ((lambda [y] y) (+ x y))) 22 33)', 55)
-        self.checkEqual('((lambda [x y] ((lambda [z] y) 0)) 22 33)', 33)
+        self.checkEqual('((fn [x] x) 5)', 5)
+        self.checkEqual('(do (define y 5) ((fn [x] y) 2))', 5)
+        self.checkEqual('((fn [x] ((fn [y] x) 2)) 1)', 1)
+        self.checkEqual('((fn [x] ((fn [y] y) x)) 11)', 11)
+        self.checkEqual('((fn [x y] ((fn [y] y) (+ x y))) 22 33)', 55)
+        self.checkEqual('((fn [x y] ((fn [z] y) 0)) 22 33)', 33)
 
     def test_resolution_in_set(self):
         self.checkRaises('(set [x 5])')

wal/ast_defs.py

@@ -55,7 +55,6 @@ class Operator(Enum):
     DEFMACRO = 'defmacro'
     MACROEXPAND = 'macroexpand'
     GENSYM = 'gensym'
-    LAMBDA = 'lambda'
     FN = 'fn'
     GET = 'get'
     CALL = 'call'

wal/implementation/core.py

@@ -277,7 +277,7 @@ def op_parse(seval, args):
     return WList([Operator.DO] + sexprs)
 
 
-def op_lambda(seval, args):
+def op_fn(seval, args):
     assert len(args) >= 2, 'lambda: expects at least two arguments (lambda (symbol | (symbol*)) sexpr)'
     assert isinstance(args[0], (WList, list, Symbol)), 'lambda: first argument must be a list of symbols or a single symbol'
     if isinstance(args[0], (list, WList)):
@@ -616,12 +616,10 @@ def op_exit(seval, args):
     Operator.UNQUOTE.value: op_unquote,
     Operator.EVAL.value: op_eval,
     Operator.PARSE.value: op_parse,
-    # Operator.DEFUN.value: op_defun,
     Operator.DEFMACRO.value: op_defmacro,
     Operator.MACROEXPAND.value: op_macroexpand,
     Operator.GENSYM.value: op_gensym,
-    Operator.LAMBDA.value: op_lambda,
-    Operator.FN.value: op_lambda,
+    Operator.FN.value: op_fn,
     Operator.GET.value: op_get,
     Operator.IMPORT.value: op_import,
     Operator.CALL.value: op_call,

wal/implementation/special.py

@@ -73,8 +73,7 @@ def op_fold_signal(seval, args):
     until the stop condition evaluates to true. '''
     assert len(args) == 4, 'fold/signal: expects 3 arguments (fold f acc stop signal)'
     func = seval.eval(args[0])
-    assert isinstance(func, list) and \
-        (func[0] == Operator.LAMBDA or func[0] == Operator.FN), 'fold/signal: not a valid function'
+    assert isinstance(func, list) and (func[0] == Operator.FN), 'fold/signal: not a valid function'
     acc = seval.eval(args[1])
     stop = args[2]
     signal = seval.eval(args[3])
@@ -89,7 +88,7 @@ def op_fold_signal(seval, args):
         if isinstance(func, Operator):
             acc = seval.eval(WList([func, WList([Operator.QUOTE, acc]), WList([Operator.QUOTE, seval.eval(signal)])]))
         else:
-            assert func[0] == Operator.LAMBDA or func[0] == Operator.FN, 'fold/signal: first argument must be a function'
+            assert func[0] == Operator.FN, 'fold/signal: first argument must be a function'
             acc = seval.eval_lambda(func, [[Operator.QUOTE, acc], [Operator.QUOTE, seval.eval(signal)]])
 
         stopped = seval.traces.step() != []

wal/libs/std/module.wal

@@ -2,7 +2,7 @@
   (define name body[0]) 
   (define provided-definitions
     (fold
-      (lambda [acc e]
+      (fn [acc e]
         (if (&& (list? e) (> (length e) 0) (= (first e) 'provide))
           (+ acc (rest e))
           acc))

wal/libs/std/std.wal

@@ -3,7 +3,7 @@
   (define name (first args))
   (define params (second args))
   (define body (rest (rest args)))
-  `(define ,name (lambda ,params ,name ,@body)))
+  `(define ,name (fn ,params ,name ,@body)))
 
 (defmacro append [xs x]
   (let ([tmp (gensym)])
@@ -14,14 +14,14 @@
 	  (let [(sym args[0][0])
 	        (body (rest args))
 		(data args[0][1])]
-	    `(map (lambda [,sym] (do ,@body)) ,data)))
+	    `(map (fn [,sym] (do ,@body)) ,data)))
 
 (defmacro for args
 	  (let [(sym args[0][0])
           (temp (gensym))
 	        (body (rest args))
 		(data args[0][1])]
-    `(let ([,temp (map (lambda [,sym] (do ,@body)) ,data)])
+    `(let ([,temp (map (fn [,sym] (do ,@body)) ,data)])
           (if ,temp (last ,temp) '()))))
 
 (defun symbol-add args
@@ -91,7 +91,7 @@
 	 (reverse args)))
 
 (defmacro defunm args
-  `(set [,(first args) (lambda ,(second args) (do ,@(rest (rest args))))]))
+  `(set [,(first args) (fn ,(second args) (do ,@(rest (rest args))))]))
 
 (defmacro car [xs]
   `(first ,xs))

wal/passes.py

@@ -138,22 +138,22 @@ def resolve_vars(expr):
                 body = [resolve_vars(sub) for sub in expr[2:]]
                 scopes.pop()
                 return WList([Operator.LET, expr[1], *body], line_info=expr.line_info)
-            elif op == Operator.LAMBDA:
+            elif op == Operator.FN:
                 args = expr[1]
                 env = {}
                 scopes.append(env)
                 if isinstance(args, (WList, list)):
                     for arg in expr[1]:
-                        assert isinstance(arg, Symbol), 'lambda: parameters must be symbols'
+                        assert isinstance(arg, Symbol), 'fn: parameters must be symbols'
                         env[arg.name] = True
                 elif isinstance(args, Symbol):
                     env[args.name] = True
                 else:
-                    assert False, 'lambda: first argument must be a list or a symbol'
+                    assert False, 'fn: first argument must be a list or a symbol'
 
                 body = [resolve_vars(sub) for sub in expr[2:]]
                 scopes.pop()
-                return WList([Operator.LAMBDA, expr[1], *body])
+                return WList([Operator.FN, expr[1], *body])
             elif op == Operator.DEFMACRO:
                 scopes[-1][expr[1].name] = True
                 return expr