cleanup after moving func/def stuff into parsing

4 files changed, 10 insertions, 152 deletions

diff --git a/neb/__init__.py b/neb/__init__.py
index f1f75d3..bfbea19 100644
--- a/neb/__init__.py
+++ b/neb/__init__.py
@@ -90,16 +90,6 @@ def evaluate(expr, env, ns=None):
         raise InterpretPanic(expr.args[0], "unable to evaluate")
 
 
-# THINGS
-#  - functions/syntax can have multiple arity definitions
-#  - functions can have multiple same-arity, different-type definitions
-
-# callable
-#  - name
-#  - implementations
-#  - signature (arguments (name and type), return type)
-
-
 class Signature:
 
     def __init__(self, *args, many=None, return_type=None):
@@ -123,7 +113,6 @@ class Signature:
         return out
 
     def get_type_by_idx(self, idx):
-        #print(f"getting type by idx: {idx}")
         if idx < len(self.args):
             return self.args[idx]
         else:
@@ -138,16 +127,6 @@ class Signature:
         return out
 
 
-
-
-
-    
-
-
-
-
-
-
 class Callable:
 
     def __init__(self, name, params, body, args=None, many=None):
@@ -156,7 +135,6 @@ class Callable:
         self.body = body
         self.args = args
         self.many = many
-        #self.type_ = TypeEnum.ANY  # TODO no it's not
         self.type_ = Type(":any")  # TODO no it's not
         self.return_type = Type(":any")
 
@@ -285,33 +263,6 @@ class NebSyntax(Special):
         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 = []
-
-        for idx, param in enumerate(params):
-            if idx < len(self.args):
-                arg = self.args[idx]
-            else:
-                arg = self.many
-            ev = evaluate(param, env, ns)
-            expected_type = evaluate(arg.type_, env, ns)
-            valid = expected_type.validate_type(ev, env, ns)
-            if not valid.value:
-                exp = f"{arg.type_}"
-                rec = f"{ev.type_}"
-                raise InterpretPanic(symbol, f"received {rec}, expected {exp}", ev)
-            ret.append(ev)
-        return ret
-    """
-
-
-#class Builtin(Function):
 class Builtin(Callable):
     
     def __init__(self, name, callable_, args=None, many=None, return_type=None):
@@ -323,23 +274,12 @@ class Builtin(Callable):
         return f"builtin function {self.name}"
 
     def call(self, expr, env, ns):
-        '''
-        self.arity_check(expr.args[0], expr.args[1:])
-        evaluated_args = self.precall(expr.args[0], expr.args[1:], env, ns)
-        return self.body(expr.args[0], evaluated_args, env, ns)
-        '''
-        #print(type(expr.args[1]))
         return self.body(expr.args[0], expr.args[1:], env, ns)
 
 
-#class UserFunction(Function):
 class UserFunction(Callable):
     
     def __init__(self, name, params, many, body):
-        #newparams, args, many = self.process_params(name, params)
-        #super().__init__(name, newparams, body, args, many)
-        #for p in params:
-        #    print(p)
         super().__init__(name, params, body, params, many)
 
     def __str__(self):
@@ -352,41 +292,7 @@ class UserFunction(Callable):
             out = out + f"{expr} "
         return out.strip() + ")"
 
-
-    '''
-    def process_params(self, name, params):
-        newparams = []
-        args = []
-        many = None
-        prev_type = False
-        first = True
-        for param in params:
-            if isinstance(param, Symbol):
-                if many is not None:
-                    raise NebPanic("& must be last argument")
-                if param.name == "&":
-                    many = Arg(param.name, TypeEnum.ANY)
-                else:
-                    newparams.append(param)
-                    args.append(Arg(param.name, TypeEnum.ANY))
-                prev_type = False
-            elif isinstance(param, Type) and not prev_type and not first:
-                if many is None:
-                    #args[-1].type_ = param.name
-                    args[-1].type_ = param
-                else:
-                    #many.type_ = param.name
-                    many.type_ = param
-                prev_type = True
-            else:
-                raise NebPanic("invalid :func signature", param)
-            first = False
-        return newparams, args, many
-    '''
-
     def call(self, expr, env, ns):
-        #self.arity_check(expr.args[0], expr.args[1:])
-        #evaluated_args = self.precall(expr.args[0], expr.args[1:], env, ns)
         evaluated_args = expr.args[1:]
         this_env = Environment(env)
         for idx, param in enumerate(self.params):
@@ -410,7 +316,7 @@ class TypeWrap:
         # if it's an any type, it's valid
         if self.parent is None:
             return Bool(True)
-        if isinstance(self.is_func, Function) or isinstance(self.is_func, MultiFunction):
+        if isinstance(self.is_func, MultiFunction):
             valid = self.is_func.call(Expr([self.name, target]), env, ns)
         else:
             valid = self.is_func(self.name, [target], env, ns)
diff --git a/neb/std/core.py b/neb/std/core.py
index 569a87d..15a7d61 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, NebSyntax, MultiFunction
+from .. import TypeEnum, Environment, Arg, Builtin, UserFunction, evaluate, interpret, parse, lex, InterpretPanic, TypeWrap, UserType, NebSyntax, MultiFunction
 from ..structs import *
 from pathlib import Path
 from datetime import datetime
@@ -21,17 +21,9 @@ t_branch = Arg("t-branch", TypeEnum.ANY)
 f_branch = Arg("f-branch", TypeEnum.ANY, optional=True)
 CORE.register("if", NebSyntax("if", interpretIf, [cond, t_branch, f_branch]))
 
-def interpretDef(symbol, args, env, ns):
-    if not isinstance(args[0], Symbol):
-        raise InterpretPanic(symbol, "requires a :symbol", args[0])
-    name = args[0].name  # NOTE: we are not evaluating the name!!
-    res = evaluate(args[1], env, ns)
-    env.register(name, res)
-    return List([])
-
 def_name_arg = Arg("name", TypeEnum.ANY)
 def_val_arg = Arg("value", TypeEnum.ANY)
-CORE.register("def", NebSyntax("def", interpretDef, [def_name_arg, def_val_arg], return_type=Type(":list")))
+CORE.register("def", NebSyntax("def", None, [def_name_arg, def_val_arg], return_type=Type(":list")))
 
 def interpretRedef(symbol, args, env, ns):
     if not isinstance(args[0], Symbol):
@@ -46,23 +38,9 @@ def interpretRedef(symbol, args, env, ns):
 
 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
-    return_type = Type(":any")
-    if isinstance(args[0], Type):
-        return_type = args[0]
-        new_args = args[1:]
-
-    if len(new_args[0].args) != 0:
-        func = UserFunction("<lambda>", new_args[0].args, new_args[1:])
-    else:
-        func = UserFunction("<lambda>", [], new_args[1:])
-    func.return_type = return_type
-    return func
-
 lambda_args_arg = Arg("args", TypeEnum.ANY)
 lambda_body_arg = Arg("body", TypeEnum.ANY)
-CORE.register("lambda", NebSyntax("lambda", interpretLambda, [lambda_args_arg, lambda_body_arg], lambda_body_arg))
+CORE.register("lambda", NebSyntax("lambda", None, [lambda_args_arg, lambda_body_arg], lambda_body_arg))
 
 def interpretForCount(symbol, args, env, ns):
     num = evaluate(args[0], env, ns)
@@ -155,34 +133,7 @@ def interpretBranch(symbol, args, env, ns):
 
 CORE.register("branch", NebSyntax("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 :symbol")
-    name = args[0].name  # NOTE: we are not evaluating the name!!
-
-    if ns is not None:
-        name = f"{ns}/{name}"
-
-    # compose a lambda
-    func = interpretLambda(None, args[1:], env, ns)
-
-    # add the name to the function
-    func.name = name
-
-    if env.contains(name) and isinstance(env.get(name), MultiFunction):
-        # TODO this doesn't check for ambiguity/overwrites!!!
-        mf = env.get(name)
-        mf.register(func)
-        env.register(name, mf)
-    else:
-        mf = MultiFunction(name)
-        mf.register(func)
-        env.register(name, mf)
-
-    #env.register(name, func)
-    return List([])
-
-CORE.register("func", NebSyntax("func", interpretFunc, [def_name_arg, lambda_args_arg, lambda_body_arg], lambda_body_arg, Type(":list")))
+CORE.register("func", NebSyntax("func", None, [def_name_arg, lambda_args_arg, lambda_body_arg], lambda_body_arg, Type(":list")))
 
 def interpretBlock(symbol, args, env, ns):
     new_env = Environment(env)
@@ -263,8 +214,9 @@ quote_arg = Arg("arg", TypeEnum.ANY)
 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)
+    #ev = evaluate(args[0], env, ns)  # TODO why do i have to evaluate twice?
+    #return evaluate(ev, env, ns)
+    return evaluate(args[0], env, ns)
 
 eval_arg = Arg("arg", TypeEnum.ANY)
 CORE.register("eval", NebSyntax("eval", interpretEval, [eval_arg]))
diff --git a/neb/std/functools.py b/neb/std/functools.py
index cfadf1c..67ef728 100644
--- a/neb/std/functools.py
+++ b/neb/std/functools.py
@@ -1,4 +1,4 @@
-from .. import TypeEnum, Environment, Arg, Builtin, Function, evaluate, InterpretPanic, NebSyntax, MultiFunction, Callable
+from .. import TypeEnum, Environment, Arg, Builtin, evaluate, InterpretPanic, NebSyntax, MultiFunction, Callable
 from ..structs import *
 
 FUNCTOOLS = Environment()
diff --git a/neb/std/repl.py b/neb/std/repl.py
index 573ecc8..0274e48 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, NebSyntax, lex, parse, MultiFunction
+from .. import TypeEnum, Environment, Arg, Builtin, UserFunction, evaluate, InterpretPanic, Callable, NebSyntax, lex, parse, MultiFunction
 from .core import interpretQuote
 from ..structs import *