refactor: get inner types when in evaluate

1 files changed, 18 insertions, 18 deletions

diff --git a/neb/__init__.py b/neb/__init__.py
index 735e4db..407ff74 100644
--- a/neb/__init__.py
+++ b/neb/__init__.py
@@ -16,9 +16,21 @@ def evaluate(expr, env, ns=None):
         return expr
     elif isinstance(expr, Symbol) or isinstance(expr, Type):
         if env.contains(expr.name):
-            return evaluate(env.get(expr.name), env, ns)
+            if isinstance(expr, Type) and expr.inner is not None:
+                typecopy = deepcopy(env.get(expr.name))
+                inner = env.get(f"{expr.inner}")
+                typecopy.name.inner = inner
+                return evaluate(typecopy, env, ns)
+            else:
+                return evaluate(env.get(expr.name), env, ns)
         elif ns is not None and env.contains(f"{ns}/{expr.name}"):
-            return evaluate(env.get(f"{ns}/{expr.name}"), env, ns)
+            if isinstance(expr, Type) and expr.inner is not None:
+                typecopy = deepcopy(env.get(f"{ns}/{expr.name}"))
+                inner = env.get(f"{expr.inner}")
+                typecopy.name.inner = inner
+                return evaluate(typecopy, env, ns)
+            else:
+                return evaluate(env.get(f"{ns}/{expr.name}"), env, ns)
         else:
             if isinstance(expr, Symbol):
                 raise NebPanic(f"no such symbol: {expr}")
@@ -84,12 +96,8 @@ class Function:
                 ret.append(param)
                 continue
             ev = evaluate(param, env, ns)
-            expected_name = arg.type_.name
-            expected_type = env.get(expected_name)
-            inner = None
-            if arg.type_.inner is not None:
-                inner = env.get(arg.type_.inner.name)
-            valid = expected_type.validate_type(ev, env, ns, inner)
+            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_}"
@@ -182,7 +190,7 @@ class TypeWrap:
         self.parent = parent
         self.is_func = is_func
 
-    def validate_type(self, target, env, ns, inner=None):
+    def validate_type(self, target, env, ns):
         # if it's an any type, it's valid
         if self.parent is None:
             return Bool(True)
@@ -191,16 +199,8 @@ class TypeWrap:
         else:
             valid = self.is_func(self.name, [target], env, ns)
         if valid.value == True:
-            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
+            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:
             parent_type = env.get(parent_type.parent.name.name)