Merge branch 'master' into feature/listtypes

8 files changed, 28 insertions, 5 deletions

diff --git a/cipher/viewer.neb b/cipher/viewer.neb
index 5cb7386..1888b76 100644
--- a/cipher/viewer.neb
+++ b/cipher/viewer.neb
@@ -1,4 +1,4 @@
-(use "../libs/ansi.neb")
+(use-as "../libs/ansi.neb" ansi)
 
 (func keys (assoc)
     (map first assoc))
@@ -17,7 +17,7 @@
             (concat out
                 (if (in? _item_ (keys codex)) 
                     (get codex _item_)
-                    (ansi-faint _item_)))))
+                    (ansi/faint _item_)))))
     out)
 
 (func print-codex (codex)
diff --git a/neb/__init__.py b/neb/__init__.py
index 0542d0d..42e1d00 100644
--- a/neb/__init__.py
+++ b/neb/__init__.py
@@ -189,6 +189,7 @@ class TypeWrap:
         self.name = ALL_TYPES[name]
         self.parent = parent
         self.is_func = is_func
+        self.type_ = TypeEnum.TYPE
 
     def validate_type(self, target, env, ns):
         # if it's an any type, it's valid
diff --git a/neb/std/core.py b/neb/std/core.py
index d846498..a44417c 100644
--- a/neb/std/core.py
+++ b/neb/std/core.py
@@ -124,25 +124,27 @@ def interpretFunc(symbol, args, env, ns):
 CORE.register("func", Builtin("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)
     ret = List([])
     for arg in args:
-        ret = evaluate(arg, 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))
 
 def interpretWhile(symbol, args, env, ns):
+    new_env = Environment(env)
     cond = args[0]
     ret = List([])
     while True:
-        ev = evaluate(cond, env, ns)
+        ev = evaluate(cond, new_env, ns)
         if not isinstance(ev, Bool):
             raise InterpretPanic(symbol, "expects a :bool condition", ev)
         if not ev.value:
             break
         for arg in args[1:]:
-            ret = evaluate(arg, env, ns)
+            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)))
diff --git a/neb/std/strings.py b/neb/std/strings.py
index 7e3177e..0da64da 100644
--- a/neb/std/strings.py
+++ b/neb/std/strings.py
@@ -47,3 +47,8 @@ def interpretRestChar(symbol, args, env, ns):
     return String(args[0].value[1:])
 
 STRINGS.register("rest-char", Builtin("rest-char", interpretRestChar, [Arg("string", TypeEnum.STRING)], return_type=Type(":string")))
+
+def interpretLength(symbol, args, env, ns):
+    return Int(len(args[0].value))
+
+STRINGS.register("length", Builtin("length", interpretLength, [Arg("string", TypeEnum.STRING)], return_type=Type(":int")))
diff --git a/neb/std/sys.py b/neb/std/sys.py
index 3dc87e9..525895a 100644
--- a/neb/std/sys.py
+++ b/neb/std/sys.py
@@ -43,3 +43,9 @@ def interpretBench(symbol, args, env, ns):
     return ret
 
 SYS.register("bench", Builtin("bench", interpretBench, [Arg("command", TypeEnum.ANY, lazy=True)], return_type=Type(":any")))
+
+def interpretEnv(symbol, args, env, ns):
+    items = os.environ[args[0].value].split(":")
+    return List([String(item) for item in items])
+
+SYS.register("env", Builtin("env", interpretEnv, [Arg("regex", TypeEnum.STRING)], return_type=Type(":string")))
diff --git a/neb/std/types.py b/neb/std/types.py
index 9cd8e6d..35dca42 100644
--- a/neb/std/types.py
+++ b/neb/std/types.py
@@ -93,6 +93,11 @@ def interpretIsHandle(symbol, args, env, ns):
 
 TYPES.register("handle?", Builtin("handle?", interpretIsHandle, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool")))
 
+def interpretIsType(symbol, args, env, ns):
+    return Bool(isinstance(args[0], TypeWrap))
+
+TYPES.register("type?", Builtin("type?", interpretIsType, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool")))
+
 # add types to env
 any_type = NebType(":any", None, interpretIsAny)
 literal_type = NebType(":literal", any_type, interpretIsLiteral)
@@ -104,6 +109,7 @@ number_type = NebType(":number", literal_type, interpretIsNumber)
 int_type = NebType(":int", number_type, interpretIsInt)
 float_type = NebType(":float", number_type, interpretIsFloat)
 handle_type = NebType(":handle", any_type, interpretIsHandle)
+type_type = NebType(":type", any_type, interpretIsType)
 
 TYPES.register(":any", any_type)
 TYPES.register(":literal", literal_type)
@@ -115,3 +121,4 @@ TYPES.register(":number", number_type)
 TYPES.register(":int", int_type)
 TYPES.register(":float", float_type)
 TYPES.register(":handle", handle_type)
+TYPES.register(":type", type_type)
diff --git a/neb/structs.py b/neb/structs.py
index 3b2cf4d..c623ed3 100644
--- a/neb/structs.py
+++ b/neb/structs.py
@@ -95,6 +95,7 @@ class String(Literal):
 class Handle:
     def __init__(self, file):
         self.file = file
+        self.type_ = TypeEnum.HANDLE
     def __str__(self):
         return f"{self.file.name} :handle"
 
diff --git a/neb/typeclass.py b/neb/typeclass.py
index a6daaf9..75f61b1 100644
--- a/neb/typeclass.py
+++ b/neb/typeclass.py
@@ -10,6 +10,7 @@ class TypeEnum(Enum):
     LITERAL = auto()
     BOOL = auto()
     HANDLE = auto()
+    TYPE = auto()
     USER = auto()
 
     def __str__(self):