From f4622e734ef2be1c3793113e93219d593e3e11fb Mon Sep 17 00:00:00 2001
From: mryouse
Date: Thu, 7 Jul 2022 02:04:28 +0000
Subject: refactor move all functions with 'lazy' to core

---
 neb/std/core.py | 43 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

(limited to 'neb/std/core.py')

diff --git a/neb/std/core.py b/neb/std/core.py
index 574455d..1645699 100644
--- a/neb/std/core.py
+++ b/neb/std/core.py
@@ -220,3 +220,46 @@ type_parent_arg = Arg("name", TypeEnum.ANY)
 type_func_arg = Arg("func", TypeEnum.ANY)
 CORE.register("type", Builtin("type", interpretType, [type_name_arg, type_parent_arg, type_func_arg]))
 
+def interpretOr(symbol, args, env, ns):
+    # or returns true for the first expression that returns true
+    for arg in args:
+        ev = evaluate(arg, env, ns)
+        if not isinstance(ev, Bool):
+            raise InterpretPanic(symbol, "requires :bool arguments")
+        if ev.value == True:
+            return ev
+    return Bool(False)
+
+or_arg = Arg("arg", TypeEnum.BOOL, lazy=True)
+CORE.register("or", Builtin("or", interpretOr, [or_arg, or_arg], or_arg, Type(":bool")))
+
+def interpretAnd(symbol, args, env, ns):
+    # and returns false for the first expression that returns false
+    for arg in args:
+        ev = evaluate(arg, env, ns)
+        if not isinstance(ev, Bool):
+            raise InterpretPanic(symbol, "requires :bool arguments")
+        if ev.value == False:
+            return ev
+    return Bool(True)
+
+CORE.register("and", Builtin("and", interpretAnd, [or_arg, or_arg], or_arg, Type(":bool")))
+
+def interpretApply(symbol, args, env, ns):
+    # TODO: to support lambdas, we can't assume the func is defined
+    func = args[0]
+    if not isinstance(func, Symbol):
+        raise InterpretPanic(symbol, "requires a symbol as its first argument", func)
+    new_expr = Expr([func] + args[1].args)
+    return evaluate(new_expr, env, ns)
+
+CORE.register("apply", Builtin("apply", interpretApply, [Arg("func", TypeEnum.ANY, lazy=True), Arg("list", TypeEnum.LIST)]))
+
+def interpretBench(symbol, args, env, ns):
+    before = datetime.now()
+    ret = evaluate(args[0], env, ns)
+    after = datetime.now()
+    print(f"bench [{symbol.line}]: {args[0]} => {after - before}")
+    return ret
+
+CORE.register("bench", Builtin("bench", interpretBench, [Arg("command", TypeEnum.ANY, lazy=True)], return_type=Type(":any")))
-- 
cgit v1.2.3


From 46cefa721d145af17bee3696ef533d752989458c Mon Sep 17 00:00:00 2001
From: mryouse
Date: Thu, 7 Jul 2022 03:47:22 +0000
Subject: refactor: 'apply' to functools

---
 neb/std/core.py      | 10 ----------
 neb/std/functools.py |  8 ++++++++
 2 files changed, 8 insertions(+), 10 deletions(-)

(limited to 'neb/std/core.py')

diff --git a/neb/std/core.py b/neb/std/core.py
index 1645699..f6b5b06 100644
--- a/neb/std/core.py
+++ b/neb/std/core.py
@@ -245,16 +245,6 @@ def interpretAnd(symbol, args, env, ns):
 
 CORE.register("and", Builtin("and", interpretAnd, [or_arg, or_arg], or_arg, Type(":bool")))
 
-def interpretApply(symbol, args, env, ns):
-    # TODO: to support lambdas, we can't assume the func is defined
-    func = args[0]
-    if not isinstance(func, Symbol):
-        raise InterpretPanic(symbol, "requires a symbol as its first argument", func)
-    new_expr = Expr([func] + args[1].args)
-    return evaluate(new_expr, env, ns)
-
-CORE.register("apply", Builtin("apply", interpretApply, [Arg("func", TypeEnum.ANY, lazy=True), Arg("list", TypeEnum.LIST)]))
-
 def interpretBench(symbol, args, env, ns):
     before = datetime.now()
     ret = evaluate(args[0], env, ns)
diff --git a/neb/std/functools.py b/neb/std/functools.py
index 8a76e98..f83c49d 100644
--- a/neb/std/functools.py
+++ b/neb/std/functools.py
@@ -34,3 +34,11 @@ def interpretMap(symbol, args, env, ns):
 
 FUNCTOOLS.register("map", Builtin("map", interpretMap, [Arg("func", TypeEnum.ANY), Arg("list", TypeEnum.LIST)], return_type=Type(":list")))
 
+# TODO I think this is wrong
+def interpretApply(symbol, args, env, ns):
+    func = args[0]
+    if not isinstance(func, Function):
+        raise InterpretPanic(symbol, "requires a symbol as its first argument", func)
+    return func.call(Expr([func] + args[1].args), env, ns)
+
+FUNCTOOLS.register("apply", Builtin("apply", interpretApply, [Arg("func", TypeEnum.ANY), Arg("list", TypeEnum.LIST)]))
-- 
cgit v1.2.3


From 3412d4d0e35dfe1faac5254199aa34f0354e992b Mon Sep 17 00:00:00 2001
From: mryouse
Date: Thu, 7 Jul 2022 03:48:05 +0000
Subject: refactor: add Macro structure under Callable, which is all core

---
 neb/__init__.py |  42 ++++++++++++------
 neb/std/core.py | 135 ++++++++++++++++++++++++++++++++------------------------
 neb/std/repl.py |   4 +-
 3 files changed, 109 insertions(+), 72 deletions(-)

(limited to 'neb/std/core.py')

diff --git a/neb/__init__.py b/neb/__init__.py
index b280914..6aeec88 100644
--- a/neb/__init__.py
+++ b/neb/__init__.py
@@ -11,7 +11,7 @@ def interpret(exprs, env, ns=None):
     return ret
 
 def evaluate(expr, env, ns=None):
-    if isinstance(expr, Literal) or isinstance(expr, Function) or isinstance(expr, TypeWrap) or isinstance(expr, List) or isinstance(expr, Handle):
+    if isinstance(expr, Literal) or isinstance(expr, Callable) or isinstance(expr, TypeWrap) or isinstance(expr, List) or isinstance(expr, Handle):
         return expr
     elif isinstance(expr, Symbol) or isinstance(expr, Type):
         if env.contains(expr.name):
@@ -57,18 +57,6 @@ class Callable:
         out.append(string_args(self.args, self.many))
         return " ".join(out).strip() + f") => {self.return_type}"
 
-    def precall(self, symbol, params, env, ns):
-        pass
-
-    def call(self, expr, env):
-        pass
-
-
-class Function(Callable):
-
-    def __init__(self, name, params, body, args=None, many=None):
-        super().__init__(name, params, body, args, many)
-
     def arity_check(self, symbol, params):
         min_arity = len([a for a in self.args if not a.optional])
         max_arity = -1 if self.many is not None else len(self.args)
@@ -83,6 +71,34 @@ class Function(Callable):
             raise InterpretPanic(symbol, f"expected [{fmt}] arguments, received {len(params)}")
         return True
 
+    def call(self, expr, env):
+        pass
+
+class Macro(Callable):
+
+    def __init__(self, name, params, body, args=None, many=None):
+        super().__init__(name, params, body, args, many)
+
+class NebMacro(Callable):
+
+    def __init__(self, name, callable_, args=None, many=None, return_type=None):
+        super().__init__(name, None, callable_, args, many)
+        if return_type is not None:
+            self.return_type = return_type
+
+    def __str__(self):
+        return f"builtin function {self.name}"
+
+    def call(self, expr, env, ns):
+        self.arity_check(expr.args[0], expr.args[1:])
+        return self.body(expr.args[0], expr.args[1:], env, ns)
+
+
+class Function(Callable):
+
+    def __init__(self, name, params, body, args=None, many=None):
+        super().__init__(name, params, body, args, many)
+
     def precall(self, symbol, params, env, ns):
         ret = []
 
diff --git a/neb/std/core.py b/neb/std/core.py
index f6b5b06..a0f2cf6 100644
--- a/neb/std/core.py
+++ b/neb/std/core.py
@@ -1,48 +1,49 @@
-from .. import TypeEnum, Environment, Arg, Builtin, UserFunction, evaluate, interpret, parse, lex, InterpretPanic, TypeWrap, Function, UserType
+from .. import TypeEnum, Environment, Arg, Builtin, UserFunction, evaluate, interpret, parse, lex, InterpretPanic, TypeWrap, Function, UserType, NebMacro
 from ..structs import *
 from pathlib import Path
 
 CORE = Environment()
 
 def interpretIf(symbol, args, env, ns):
-    if args[0].value:
+    cond = evaluate(args[0], env, ns)
+    if not isinstance(cond, Bool):
+        raise InterpretPanic(symbol, "requires a :bool condition", cond)
+
+    if cond.value:
         return evaluate(args[1], env, ns)
     elif len(args) == 3:
         return evaluate(args[2], env, ns)
     return List([])
 
 cond = Arg("cond", TypeEnum.BOOL)
-t_branch = Arg("t-branch", TypeEnum.ANY, lazy=True)
-f_branch = Arg("f-branch", TypeEnum.ANY, optional=True, lazy=True)
-CORE.register("if", Builtin("if", interpretIf, [cond, t_branch, f_branch]))
+t_branch = Arg("t-branch", TypeEnum.ANY)
+f_branch = Arg("f-branch", TypeEnum.ANY, optional=True)
+CORE.register("if", NebMacro("if", interpretIf, [cond, t_branch, f_branch]))
 
 def interpretDef(symbol, args, env, ns):
-
     if not isinstance(args[0], Symbol):
-        raise InterpretPanic(symbol, "requires a :string name", args[0])
+        raise InterpretPanic(symbol, "requires a :symbol", args[0])
     name = args[0].name  # NOTE: we are not evaluating the name!!
-    if not isinstance(name, str):
-        raise InterpretPanic(symbol, "requires a :string name")
-
-    env.register(name, args[1])  # TODO since this isn't lazily evaluated, side effects are allowed (bad!)
-
+    res = evaluate(args[1], env, ns)
+    env.register(name, res)
     return List([])
 
-def_name_arg = Arg("name", TypeEnum.ANY, lazy=True)
+def_name_arg = Arg("name", TypeEnum.ANY)
 def_val_arg = Arg("value", TypeEnum.ANY)
-CORE.register("def", Builtin("def", interpretDef, [def_name_arg, def_val_arg], return_type=Type(":list")))
+CORE.register("def", NebMacro("def", interpretDef, [def_name_arg, def_val_arg], return_type=Type(":list")))
 
 def interpretRedef(symbol, args, env, ns):
     if not isinstance(args[0], Symbol):
-        raise InterpretPanic(symbol, "requires a :string name", args[0])
+        raise InterpretPanic(symbol, "requires a :symbol", args[0])
     name = args[0].name  # NOTE: we are not evaluating the name!!
     if not env.contains(name):
         raise InterpretPanic(symbol, "not previously defined", args[0])
 
-    env.reregister(name, args[1])
+    res = evaluate(args[1], env, ns)
+    env.reregister(name, res)
     return List([])
 
-CORE.register("redef", Builtin("redef", interpretRedef, [def_name_arg, def_val_arg], return_type=Type(":list")))
+CORE.register("redef", NebMacro("redef", interpretRedef, [def_name_arg, def_val_arg], return_type=Type(":list")))
 
 def interpretLambda(symbol, args, env, ns):
     new_args = args
@@ -58,14 +59,17 @@ def interpretLambda(symbol, args, env, ns):
     func.return_type = return_type
     return func
 
-lambda_args_arg = Arg("args", TypeEnum.ANY, lazy=True)
-lambda_body_arg = Arg("body", TypeEnum.ANY, lazy=True)
-CORE.register("lambda", Builtin("lambda", interpretLambda, [lambda_args_arg, lambda_body_arg], lambda_body_arg))
+lambda_args_arg = Arg("args", TypeEnum.ANY)
+lambda_body_arg = Arg("body", TypeEnum.ANY)
+CORE.register("lambda", NebMacro("lambda", interpretLambda, [lambda_args_arg, lambda_body_arg], lambda_body_arg))
 
 def interpretForCount(symbol, args, env, ns):
+    num = evaluate(args[0], env, ns)
+    if not isinstance(num, Int):
+        raise InterpretPanic(symbol, "count must be an :int", num)
     new_env = Environment(env)
     ret = None
-    for idx in range(0, args[0].value):
+    for idx in range(0, num.value):
         new_env.register("idx", Int(idx + 1))
         for arg in args[1:]:
             ret = evaluate(arg, new_env, ns)
@@ -74,13 +78,16 @@ def interpretForCount(symbol, args, env, ns):
     return ret
 
 for_count_arg = Arg("count", TypeEnum.INT)
-for_body_arg = Arg("body", TypeEnum.ANY, lazy=True)
-CORE.register("for-count", Builtin("for-count", interpretForCount, [for_count_arg, for_body_arg], for_body_arg))
+for_body_arg = Arg("body", TypeEnum.ANY)
+CORE.register("for-count", NebMacro("for-count", interpretForCount, [for_count_arg, for_body_arg], for_body_arg))
 
 def interpretForEach(symbol, args, env, ns):
+    coll = evaluate(args[0], env, ns)
+    if not isinstance(coll, List):
+        raise InterpretPanic(symbol, "coll must be a :list", coll)
     new_env = Environment(env)
     ret = None
-    for item in args[0].args:
+    for item in coll.args:
         new_env.register("_item_", evaluate(item, env, ns))
         for arg in args[1:]:
             ret = evaluate(arg, new_env, ns)
@@ -89,12 +96,12 @@ def interpretForEach(symbol, args, env, ns):
     return ret
 
 for_each_arg = Arg("list", TypeEnum.LIST)
-CORE.register("for-each", Builtin("for-each", interpretForEach, [for_each_arg, for_body_arg], for_body_arg))
+CORE.register("for-each", NebMacro("for-each", interpretForEach, [for_each_arg, for_body_arg], for_body_arg))
 
 def interpretBranch(symbol, args, env, ns):
     for arg in args:
         if len(arg.args) != 2:
-            raise InterpretPanic(symbol, "each branch requires two expressions")
+            raise InterpretPanic(symbol, "each branch requires two expressions", len(arg.args))
         cond = evaluate(arg.args[0], env, ns)  # this is the condition
         if not isinstance(cond, Bool):
             raise InterpretPanic(symbol, "branch condition must be :bool", cond)
@@ -102,11 +109,11 @@ def interpretBranch(symbol, args, env, ns):
             return evaluate(arg.args[1], env, ns)
     return List([])
 
-CORE.register("branch", Builtin("branch", interpretBranch, [for_body_arg], for_body_arg))
+CORE.register("branch", NebMacro("branch", interpretBranch, [for_body_arg], for_body_arg))
 
 def interpretFunc(symbol, args, env, ns):
     if not isinstance(args[0], Symbol):
-        raise InterpretPanic(symbol, "requires a :string name")
+        raise InterpretPanic(symbol, "requires a :symbol")
     name = args[0].name  # NOTE: we are not evaluating the name!!
 
     if ns is not None:
@@ -121,7 +128,7 @@ def interpretFunc(symbol, args, env, ns):
     env.register(name, func)
     return List([])
 
-CORE.register("func", Builtin("func", interpretFunc, [def_name_arg, lambda_args_arg, lambda_body_arg], lambda_body_arg, Type(":list")))
+CORE.register("func", NebMacro("func", interpretFunc, [def_name_arg, lambda_args_arg, lambda_body_arg], lambda_body_arg, Type(":list")))
 
 def interpretBlock(symbol, args, env, ns):
     new_env = Environment(env)
@@ -130,8 +137,8 @@ def interpretBlock(symbol, args, env, ns):
         ret = evaluate(arg, new_env, ns)
     return ret
 
-block_arg = Arg("expr", TypeEnum.ANY, lazy=True)
-CORE.register("block", Builtin("block", interpretBlock, [block_arg], block_arg))
+block_arg = Arg("expr", TypeEnum.ANY)
+CORE.register("block", NebMacro("block", interpretBlock, [block_arg], block_arg))
 
 def interpretWhile(symbol, args, env, ns):
     new_env = Environment(env)
@@ -140,18 +147,21 @@ def interpretWhile(symbol, args, env, ns):
     while True:
         ev = evaluate(cond, new_env, ns)
         if not isinstance(ev, Bool):
-            raise InterpretPanic(symbol, "expects a :bool condition", ev)
+            raise InterpretPanic(symbol, "requires a :bool condition", cond)
         if not ev.value:
             break
         for arg in args[1:]:
             ret = evaluate(arg, new_env, ns)
     return ret
 
-CORE.register("while", Builtin("while", interpretWhile, [Arg("cond", TypeEnum.BOOL, lazy=True)], Arg("expr", TypeEnum.ANY, lazy=True)))
+CORE.register("while", NebMacro("while", interpretWhile, [Arg("cond", TypeEnum.BOOL)], Arg("expr", TypeEnum.ANY)))
 
+# NOTE this doesn't technically need to be a macro
 def interpretUse(symbol, args, env, ns):
-    target_file_name = args[0].value
-    target_file = Path(target_file_name).resolve()
+    target = evaluate(args[0], env, ns)
+    if not isinstance(target, String):
+        raise InterpretPanic(symbol, "filename must be a :string", target)
+    target_file = Path(target.value).resolve()
     if not target_file.exists():
         raise InterpretPanic(symbol, "no such file", target_file)
     with open(target_file, "r") as fil:
@@ -159,38 +169,48 @@ def interpretUse(symbol, args, env, ns):
     interpret(parse(lex(data)), env, ns)
     return List([])
 
-CORE.register("use", Builtin("use", interpretUse, [Arg("filename", TypeEnum.STRING)], return_type=Type(":list")))
+CORE.register("use", NebMacro("use", interpretUse, [Arg("filename", TypeEnum.STRING)], return_type=Type(":list")))
 
+# NOTE this doesn't technically need to be a macro
 def interpretAssert(symbol, args, env, ns):
-    if args[0].value != True:
+    cond = evaluate(args[0], env, ns)
+    if not isinstance(cond, Bool):
+        raise InterpretPanic(symbol, "requires a :bool condition", cond)
+    if cond.value != True:
         raise InterpretPanic(symbol, "assertion failed")
     return List([])
 
-CORE.register("assert", Builtin("assert", interpretAssert, [Arg("cond", TypeEnum.BOOL)], return_type=Type(":list")))
+CORE.register("assert", NebMacro("assert", interpretAssert, [Arg("cond", TypeEnum.BOOL)], return_type=Type(":list")))
 
 def interpretUseAs(symbol, args, env, ns):
-    target_file_name = args[0].value
-    target_file = Path(target_file_name).resolve()
+    target = evaluate(args[0], env, ns)
+    if not isinstance(target, String):
+        raise InterpretPanic(symbol, "filename must be a :string", target)
+    target_file = Path(target.value).resolve()
     if not target_file.exists():
         raise InterpretPanic(symbol, "no such file", target_file)
+    if not isinstance(args[1], Symbol):
+        raise InterpretPanic(symbol, "requires a :symbol", args[1])
+    new_ns = args[1].name
     with open(target_file, "r") as fil:
         data = fil.read()
-    interpret(parse(lex(data)), env, args[1].name)
+    interpret(parse(lex(data)), env, new_ns)
     return List([])
 
-CORE.register("use-as", Builtin("use-as", interpretUseAs, [Arg("filename", TypeEnum.STRING), Arg("namespace", TypeEnum.ANY, lazy=True)], return_type=Type(":list")))
+CORE.register("use-as", NebMacro("use-as", interpretUseAs, [Arg("filename", TypeEnum.STRING), Arg("namespace", TypeEnum.ANY)], return_type=Type(":list")))
 
 def interpretQuote(symbol, args, env, ns):
     return args[0]
 
-quote_arg = Arg("arg", TypeEnum.ANY, lazy=True)
-CORE.register("quote", Builtin("quote", interpretQuote, [quote_arg]))
+quote_arg = Arg("arg", TypeEnum.ANY)
+CORE.register("quote", NebMacro("quote", interpretQuote, [quote_arg]))
 
 def interpretEval(symbol, args, env, ns):
-    return evaluate(args[0], env, ns) # TODO why do i have to explicitly evaluate here?
+    ev = evaluate(args[0], env, ns)  # TODO why do i have to evaluate twice?
+    return evaluate(ev, env, ns)
 
 eval_arg = Arg("arg", TypeEnum.ANY)
-CORE.register("eval", Builtin("eval", interpretEval, [eval_arg]))
+CORE.register("eval", NebMacro("eval", interpretEval, [eval_arg]))
 
 def interpretType(symbol, args, env, ns):
     # (type typename parent func)
@@ -201,13 +221,14 @@ def interpretType(symbol, args, env, ns):
     # TODO we may need to do namespace things here
     # also, we probably shouldn't be able to rename types
 
-    if not isinstance(args[1], TypeWrap):
-        raise InterpretPanic(symbol, "parent must be a valid type", args[1])
-    elif not env.contains(args[1].name):
-        raise InterpretPanic(symbol, f"no such type {args[1]}")
-    parent = env.get(args[1].name)
+    parent_type = evaluate(args[1], env, ns)
+    if not isinstance(parent_type, TypeWrap):
+        raise InterpretPanic(symbol, "parent must be a valid type", parent_type)
+    elif not env.contains(parent_type.name):
+        raise InterpretPanic(symbol, f"no such type {parent_type}")
+    parent = env.get(parent_type.name)
 
-    func = args[2]
+    func = evaluate(args[2], env, ns)
     if not isinstance(func, Function):
         raise InterpretPanic(symbol, "validation must be a :func", func)
 
@@ -215,10 +236,10 @@ def interpretType(symbol, args, env, ns):
     env.register(name, new_type)
     return List([])
 
-type_name_arg = Arg("name", TypeEnum.ANY, lazy=True)
+type_name_arg = Arg("name", TypeEnum.ANY)
 type_parent_arg = Arg("name", TypeEnum.ANY)
 type_func_arg = Arg("func", TypeEnum.ANY)
-CORE.register("type", Builtin("type", interpretType, [type_name_arg, type_parent_arg, type_func_arg]))
+CORE.register("type", NebMacro("type", interpretType, [type_name_arg, type_parent_arg, type_func_arg]))
 
 def interpretOr(symbol, args, env, ns):
     # or returns true for the first expression that returns true
@@ -230,8 +251,8 @@ def interpretOr(symbol, args, env, ns):
             return ev
     return Bool(False)
 
-or_arg = Arg("arg", TypeEnum.BOOL, lazy=True)
-CORE.register("or", Builtin("or", interpretOr, [or_arg, or_arg], or_arg, Type(":bool")))
+or_arg = Arg("arg", TypeEnum.BOOL)
+CORE.register("or", NebMacro("or", interpretOr, [or_arg, or_arg], or_arg, Type(":bool")))
 
 def interpretAnd(symbol, args, env, ns):
     # and returns false for the first expression that returns false
@@ -252,4 +273,4 @@ def interpretBench(symbol, args, env, ns):
     print(f"bench [{symbol.line}]: {args[0]} => {after - before}")
     return ret
 
-CORE.register("bench", Builtin("bench", interpretBench, [Arg("command", TypeEnum.ANY, lazy=True)], return_type=Type(":any")))
+CORE.register("bench", NebMacro("bench", interpretBench, [Arg("command", TypeEnum.ANY)], return_type=Type(":any")))
diff --git a/neb/std/repl.py b/neb/std/repl.py
index 16efb20..73f82d6 100644
--- a/neb/std/repl.py
+++ b/neb/std/repl.py
@@ -1,10 +1,10 @@
-from .. import TypeEnum, Environment, Arg, Builtin, UserFunction, Function, evaluate, InterpretPanic
+from .. import TypeEnum, Environment, Arg, Builtin, UserFunction, Function, evaluate, InterpretPanic, Callable
 from ..structs import *
 
 REPL = Environment()
 
 def interpretHowTo(symbol, args, env, ns):
-    if not isinstance(args[0], Function):
+    if not isinstance(args[0], Callable):
         raise InterpretPanic(symbol, "expects a :func", args[0])
     print(args[0].describe())
     return List([])
-- 
cgit v1.2.3


From 5f484ca29fa49584fb82d789cde1ac084dfef30e Mon Sep 17 00:00:00 2001
From: mryouse
Date: Sat, 9 Jul 2022 00:14:36 +0000
Subject: rename 'macros' to 'syntax'

---
 neb/__init__.py |  6 +++---
 neb/std/core.py | 40 ++++++++++++++++++++--------------------
 neb/std/repl.py |  8 ++++----
 3 files changed, 27 insertions(+), 27 deletions(-)

(limited to 'neb/std/core.py')

diff --git a/neb/__init__.py b/neb/__init__.py
index 4831019..71d06e5 100644
--- a/neb/__init__.py
+++ b/neb/__init__.py
@@ -74,12 +74,12 @@ class Callable:
     def call(self, expr, env):
         pass
 
-class Macro(Callable):
+class Special(Callable):
 
     def __init__(self, name, params, body, args=None, many=None):
         super().__init__(name, params, body, args, many)
 
-class NebMacro(Macro):
+class NebSyntax(Special):
 
     def __init__(self, name, callable_, args=None, many=None, return_type=None):
         super().__init__(name, None, callable_, args, many)
@@ -87,7 +87,7 @@ class NebMacro(Macro):
             self.return_type = return_type
 
     def __str__(self):
-        return f"builtin function {self.name}"
+        return f"syntax function {self.name}"
 
     def call(self, expr, env, ns):
         self.arity_check(expr.args[0], expr.args[1:])
diff --git a/neb/std/core.py b/neb/std/core.py
index a0f2cf6..cf0686b 100644
--- a/neb/std/core.py
+++ b/neb/std/core.py
@@ -1,4 +1,4 @@
-from .. import TypeEnum, Environment, Arg, Builtin, UserFunction, evaluate, interpret, parse, lex, InterpretPanic, TypeWrap, Function, UserType, NebMacro
+from .. import TypeEnum, Environment, Arg, Builtin, UserFunction, evaluate, interpret, parse, lex, InterpretPanic, TypeWrap, Function, UserType, NebSyntax
 from ..structs import *
 from pathlib import Path
 
@@ -18,7 +18,7 @@ def interpretIf(symbol, args, env, ns):
 cond = Arg("cond", TypeEnum.BOOL)
 t_branch = Arg("t-branch", TypeEnum.ANY)
 f_branch = Arg("f-branch", TypeEnum.ANY, optional=True)
-CORE.register("if", NebMacro("if", interpretIf, [cond, t_branch, f_branch]))
+CORE.register("if", NebSyntax("if", interpretIf, [cond, t_branch, f_branch]))
 
 def interpretDef(symbol, args, env, ns):
     if not isinstance(args[0], Symbol):
@@ -30,7 +30,7 @@ def interpretDef(symbol, args, env, ns):
 
 def_name_arg = Arg("name", TypeEnum.ANY)
 def_val_arg = Arg("value", TypeEnum.ANY)
-CORE.register("def", NebMacro("def", interpretDef, [def_name_arg, def_val_arg], return_type=Type(":list")))
+CORE.register("def", NebSyntax("def", interpretDef, [def_name_arg, def_val_arg], return_type=Type(":list")))
 
 def interpretRedef(symbol, args, env, ns):
     if not isinstance(args[0], Symbol):
@@ -43,7 +43,7 @@ def interpretRedef(symbol, args, env, ns):
     env.reregister(name, res)
     return List([])
 
-CORE.register("redef", NebMacro("redef", interpretRedef, [def_name_arg, def_val_arg], return_type=Type(":list")))
+CORE.register("redef", NebSyntax("redef", interpretRedef, [def_name_arg, def_val_arg], return_type=Type(":list")))
 
 def interpretLambda(symbol, args, env, ns):
     new_args = args
@@ -61,7 +61,7 @@ def interpretLambda(symbol, args, env, ns):
 
 lambda_args_arg = Arg("args", TypeEnum.ANY)
 lambda_body_arg = Arg("body", TypeEnum.ANY)
-CORE.register("lambda", NebMacro("lambda", interpretLambda, [lambda_args_arg, lambda_body_arg], lambda_body_arg))
+CORE.register("lambda", NebSyntax("lambda", interpretLambda, [lambda_args_arg, lambda_body_arg], lambda_body_arg))
 
 def interpretForCount(symbol, args, env, ns):
     num = evaluate(args[0], env, ns)
@@ -79,7 +79,7 @@ def interpretForCount(symbol, args, env, ns):
 
 for_count_arg = Arg("count", TypeEnum.INT)
 for_body_arg = Arg("body", TypeEnum.ANY)
-CORE.register("for-count", NebMacro("for-count", interpretForCount, [for_count_arg, for_body_arg], for_body_arg))
+CORE.register("for-count", NebSyntax("for-count", interpretForCount, [for_count_arg, for_body_arg], for_body_arg))
 
 def interpretForEach(symbol, args, env, ns):
     coll = evaluate(args[0], env, ns)
@@ -96,7 +96,7 @@ def interpretForEach(symbol, args, env, ns):
     return ret
 
 for_each_arg = Arg("list", TypeEnum.LIST)
-CORE.register("for-each", NebMacro("for-each", interpretForEach, [for_each_arg, for_body_arg], for_body_arg))
+CORE.register("for-each", NebSyntax("for-each", interpretForEach, [for_each_arg, for_body_arg], for_body_arg))
 
 def interpretBranch(symbol, args, env, ns):
     for arg in args:
@@ -109,7 +109,7 @@ def interpretBranch(symbol, args, env, ns):
             return evaluate(arg.args[1], env, ns)
     return List([])
 
-CORE.register("branch", NebMacro("branch", interpretBranch, [for_body_arg], for_body_arg))
+CORE.register("branch", NebSyntax("branch", interpretBranch, [for_body_arg], for_body_arg))
 
 def interpretFunc(symbol, args, env, ns):
     if not isinstance(args[0], Symbol):
@@ -128,7 +128,7 @@ def interpretFunc(symbol, args, env, ns):
     env.register(name, func)
     return List([])
 
-CORE.register("func", NebMacro("func", interpretFunc, [def_name_arg, lambda_args_arg, lambda_body_arg], lambda_body_arg, Type(":list")))
+CORE.register("func", NebSyntax("func", interpretFunc, [def_name_arg, lambda_args_arg, lambda_body_arg], lambda_body_arg, Type(":list")))
 
 def interpretBlock(symbol, args, env, ns):
     new_env = Environment(env)
@@ -138,7 +138,7 @@ def interpretBlock(symbol, args, env, ns):
     return ret
 
 block_arg = Arg("expr", TypeEnum.ANY)
-CORE.register("block", NebMacro("block", interpretBlock, [block_arg], block_arg))
+CORE.register("block", NebSyntax("block", interpretBlock, [block_arg], block_arg))
 
 def interpretWhile(symbol, args, env, ns):
     new_env = Environment(env)
@@ -154,7 +154,7 @@ def interpretWhile(symbol, args, env, ns):
             ret = evaluate(arg, new_env, ns)
     return ret
 
-CORE.register("while", NebMacro("while", interpretWhile, [Arg("cond", TypeEnum.BOOL)], Arg("expr", TypeEnum.ANY)))
+CORE.register("while", NebSyntax("while", interpretWhile, [Arg("cond", TypeEnum.BOOL)], Arg("expr", TypeEnum.ANY)))
 
 # NOTE this doesn't technically need to be a macro
 def interpretUse(symbol, args, env, ns):
@@ -169,7 +169,7 @@ def interpretUse(symbol, args, env, ns):
     interpret(parse(lex(data)), env, ns)
     return List([])
 
-CORE.register("use", NebMacro("use", interpretUse, [Arg("filename", TypeEnum.STRING)], return_type=Type(":list")))
+CORE.register("use", NebSyntax("use", interpretUse, [Arg("filename", TypeEnum.STRING)], return_type=Type(":list")))
 
 # NOTE this doesn't technically need to be a macro
 def interpretAssert(symbol, args, env, ns):
@@ -180,7 +180,7 @@ def interpretAssert(symbol, args, env, ns):
         raise InterpretPanic(symbol, "assertion failed")
     return List([])
 
-CORE.register("assert", NebMacro("assert", interpretAssert, [Arg("cond", TypeEnum.BOOL)], return_type=Type(":list")))
+CORE.register("assert", NebSyntax("assert", interpretAssert, [Arg("cond", TypeEnum.BOOL)], return_type=Type(":list")))
 
 def interpretUseAs(symbol, args, env, ns):
     target = evaluate(args[0], env, ns)
@@ -197,20 +197,20 @@ def interpretUseAs(symbol, args, env, ns):
     interpret(parse(lex(data)), env, new_ns)
     return List([])
 
-CORE.register("use-as", NebMacro("use-as", interpretUseAs, [Arg("filename", TypeEnum.STRING), Arg("namespace", TypeEnum.ANY)], return_type=Type(":list")))
+CORE.register("use-as", NebSyntax("use-as", interpretUseAs, [Arg("filename", TypeEnum.STRING), Arg("namespace", TypeEnum.ANY)], return_type=Type(":list")))
 
 def interpretQuote(symbol, args, env, ns):
     return args[0]
 
 quote_arg = Arg("arg", TypeEnum.ANY)
-CORE.register("quote", NebMacro("quote", interpretQuote, [quote_arg]))
+CORE.register("quote", NebSyntax("quote", interpretQuote, [quote_arg]))
 
 def interpretEval(symbol, args, env, ns):
     ev = evaluate(args[0], env, ns)  # TODO why do i have to evaluate twice?
     return evaluate(ev, env, ns)
 
 eval_arg = Arg("arg", TypeEnum.ANY)
-CORE.register("eval", NebMacro("eval", interpretEval, [eval_arg]))
+CORE.register("eval", NebSyntax("eval", interpretEval, [eval_arg]))
 
 def interpretType(symbol, args, env, ns):
     # (type typename parent func)
@@ -239,7 +239,7 @@ def interpretType(symbol, args, env, ns):
 type_name_arg = Arg("name", TypeEnum.ANY)
 type_parent_arg = Arg("name", TypeEnum.ANY)
 type_func_arg = Arg("func", TypeEnum.ANY)
-CORE.register("type", NebMacro("type", interpretType, [type_name_arg, type_parent_arg, type_func_arg]))
+CORE.register("type", NebSyntax("type", interpretType, [type_name_arg, type_parent_arg, type_func_arg]))
 
 def interpretOr(symbol, args, env, ns):
     # or returns true for the first expression that returns true
@@ -252,7 +252,7 @@ def interpretOr(symbol, args, env, ns):
     return Bool(False)
 
 or_arg = Arg("arg", TypeEnum.BOOL)
-CORE.register("or", NebMacro("or", interpretOr, [or_arg, or_arg], or_arg, Type(":bool")))
+CORE.register("or", NebSyntax("or", interpretOr, [or_arg, or_arg], or_arg, Type(":bool")))
 
 def interpretAnd(symbol, args, env, ns):
     # and returns false for the first expression that returns false
@@ -264,7 +264,7 @@ def interpretAnd(symbol, args, env, ns):
             return ev
     return Bool(True)
 
-CORE.register("and", Builtin("and", interpretAnd, [or_arg, or_arg], or_arg, Type(":bool")))
+CORE.register("and", NebSyntax("and", interpretAnd, [or_arg, or_arg], or_arg, Type(":bool")))
 
 def interpretBench(symbol, args, env, ns):
     before = datetime.now()
@@ -273,4 +273,4 @@ def interpretBench(symbol, args, env, ns):
     print(f"bench [{symbol.line}]: {args[0]} => {after - before}")
     return ret
 
-CORE.register("bench", NebMacro("bench", interpretBench, [Arg("command", TypeEnum.ANY)], return_type=Type(":any")))
+CORE.register("bench", NebSyntax("bench", interpretBench, [Arg("command", TypeEnum.ANY)], return_type=Type(":any")))
diff --git a/neb/std/repl.py b/neb/std/repl.py
index b888d1a..e8f2857 100644
--- a/neb/std/repl.py
+++ b/neb/std/repl.py
@@ -1,4 +1,4 @@
-from .. import TypeEnum, Environment, Arg, Builtin, UserFunction, Function, evaluate, InterpretPanic, Callable, Macro, lex, parse
+from .. import TypeEnum, Environment, Arg, Builtin, UserFunction, Function, evaluate, InterpretPanic, Callable, NebSyntax, lex, parse
 from .core import interpretQuote
 from ..structs import *
 
@@ -30,11 +30,11 @@ def interpretUserSymbols(symbol, args, env, ns):
 
 REPL.register("user-symbols", Builtin("user-symbols", interpretUserSymbols, [], return_type=Type(":list")))
 
-def interpretMacros(symbol, args, env, ns):
-    keys = [Symbol(k, -1) for k,v in sorted(env.environment.items()) if isinstance(v, Macro)]
+def interpretSyntax(symbol, args, env, ns):
+    keys = [Symbol(k, -1) for k,v in sorted(env.environment.items()) if isinstance(v, NebSyntax)]
     return List(keys)
 
-REPL.register("macros", Builtin("macros", interpretMacros, [], return_type=Type(":list")))
+REPL.register("syntax", Builtin("syntax", interpretSyntax, [], return_type=Type(":list")))
 
 def interpretParseNeb(symbol, args, env, ns):
     return interpretQuote(None, [parse(lex(args[0].value))[0]], env, ns)
-- 
cgit v1.2.3


From f6815e804fb35621e84031ef880d183140b7a523 Mon Sep 17 00:00:00 2001
From: mryouse
Date: Sat, 9 Jul 2022 01:59:47 +0000
Subject: implement 'try'

---
 neb/std/core.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'neb/std/core.py')

diff --git a/neb/std/core.py b/neb/std/core.py
index cf0686b..9e2e743 100644
--- a/neb/std/core.py
+++ b/neb/std/core.py
@@ -274,3 +274,13 @@ def interpretBench(symbol, args, env, ns):
     return ret
 
 CORE.register("bench", NebSyntax("bench", interpretBench, [Arg("command", TypeEnum.ANY)], return_type=Type(":any")))
+
+def interpretTry(symbol, args, env, ns):
+    try:
+        return evaluate(args[0], env, ns)
+    except NebPanic as e:
+        new_env = Environment(env)
+        new_env.register("_panic_", String(f"{e}"))
+        return evaluate(args[1], new_env, ns)
+
+CORE.register("try", NebSyntax("try", interpretTry, [Arg("expr", TypeEnum.ANY), Arg("except", TypeEnum.ANY)], return_type=Type(":any")))
-- 
cgit v1.2.3