refactor: get rid of deepcopy for performance, pass inner type instead

1 files changed, 14 insertions, 6 deletions

diff --git a/neb/__init__.py b/neb/__init__.py
index 3ba9172..0757071 100644
--- a/neb/__init__.py
+++ b/neb/__init__.py
@@ -84,12 +84,12 @@ class Function:
                 ret.append(param)
                 continue
             ev = evaluate(param, env, ns)
-            #expected_name = f"{arg.type_}"
             expected_name = arg.type_.name
-            expected_type = deepcopy(env.get(expected_name))
+            expected_type = env.get(expected_name)
+            inner = None
             if arg.type_.inner is not None:
-                expected_type.name.inner = arg.type_.inner
-            valid = expected_type.validate_type(ev, env, ns)
+                inner = env.get(arg.type_.inner.name)
+            valid = expected_type.validate_type(ev, env, ns, inner)
             if not valid.value:
                 exp = f"{arg.type_}"
                 rec = f"{ev.type_}"
@@ -182,7 +182,7 @@ class TypeWrap:
         self.parent = parent
         self.is_func = is_func
 
-    def validate_type(self, target, env, ns):
+    def validate_type(self, target, env, ns, inner=None):
         # if it's an any type, it's valid
         if self.parent is None:
             return Bool(True)
@@ -191,7 +191,15 @@ class TypeWrap:
         else:
             valid = self.is_func(self.name, [target], env, ns)
         if valid.value == True:
-            return valid
+            if inner is None:
+                return valid
+            else:
+                for arg in target.args:
+                    valid = inner.validate_type(arg, env, ns)
+                    if valid.value == False:
+                        return Bool(False)
+                return valid
+
         #parent_type = env.get(f"{target.type_}")
         parent_type = env.get(target.type_.name)
         while valid.value != True and parent_type.parent is not None: