From 8e1e9531e587783dd4518b8464cce5e497dfd0ff Mon Sep 17 00:00:00 2001
From: mryouse
Date: Thu, 23 Jun 2022 02:52:49 +0000
Subject: try and speed up typechecking by calling function directly

---
 neb/__init__.py  |  7 +++++--
 neb/std/types.py | 16 ++++++++--------
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/neb/__init__.py b/neb/__init__.py
index 7e3075b..c9e385e 100644
--- a/neb/__init__.py
+++ b/neb/__init__.py
@@ -177,13 +177,16 @@ class TypeWrap:
         # if it's an any type, it's valid
         if self.parent is None:
             return Bool(True)
-        valid = self.is_func.call(List([None, target]), env, ns)
+        if isinstance(self.is_func, UserFunction):
+            valid = self.is_func.call(Expr([None, target]), env, ns)
+        else:
+            valid = self.is_func(None, [target], env, ns)
         if valid.value == True:
             return valid
         parent_type = env.get(f"{target.type_}")
         while valid.value != True and parent_type.parent is not None:
             parent_type = env.get(f"{parent_type.parent}")
-            valid = Bool(self.name == parent_type.name)
+            valid = Bool(self.name == parent_type.name) # TODO wrong
         return valid
 
     def __str__(self):
diff --git a/neb/std/types.py b/neb/std/types.py
index 855a1d9..b5fb993 100644
--- a/neb/std/types.py
+++ b/neb/std/types.py
@@ -70,14 +70,14 @@ def interpretIsLiteral(symbol, args, env, ns):
 TYPES.register("literal?", Builtin("literal?", interpretIsLiteral, [Arg("arg", TypeEnum.ANY)]))
 
 # add types to env
-any_type = NebType(":any", None, Builtin("any?", interpretIsAny, [Arg("arg", TypeEnum.ANY)]))
-literal_type = NebType(":literal", any_type, Builtin("literal?", interpretIsLiteral, [Arg("arg", TypeEnum.ANY)]))
-string_type = NebType(":string", literal_type, Builtin("string?", interpretIsString, [Arg("arg", TypeEnum.ANY)]))
-list_type = NebType(":list", any_type, Builtin("list?", interpretIsList, [Arg("arg", TypeEnum.ANY)]))
-bool_type = NebType(":bool", literal_type, Builtin("bool?", interpretIsBool, [Arg("arg", TypeEnum.ANY)]))
-number_type = NebType(":number", literal_type, Builtin("number?", interpretIsNumber, [Arg("arg", TypeEnum.ANY)]))
-int_type = NebType(":int", number_type, Builtin("int?", interpretIsInt, [Arg("arg", TypeEnum.ANY)]))
-float_type = NebType(":float", number_type, Builtin("float?", interpretIsFloat, [Arg("arg", TypeEnum.ANY)]))
+any_type = NebType(":any", None, interpretIsAny)
+literal_type = NebType(":literal", any_type, interpretIsLiteral)
+string_type = NebType(":string", literal_type, interpretIsString)
+list_type = NebType(":list", any_type, interpretIsList)
+bool_type = NebType(":bool", literal_type, interpretIsBool)
+number_type = NebType(":number", literal_type, interpretIsNumber)
+int_type = NebType(":int", number_type, interpretIsInt)
+float_type = NebType(":float", number_type, interpretIsFloat)
 
 TYPES.register(":any", any_type)
 TYPES.register(":literal", literal_type)
-- 
cgit v1.2.3