bugfix: :[] return types in std

8 files changed, 34 insertions, 35 deletions

diff --git a/neb/std/fs.py b/neb/std/fs.py
index 8500140..68fbc71 100644
--- a/neb/std/fs.py
+++ b/neb/std/fs.py
@@ -67,7 +67,7 @@ def interpretOpenRead(symbol, args, env, ns):
         raise InterpretPanic(symbol, "cannot open {fil} for reading")
     return Handle(f)
 
-openread_func = Builtin("open-read", interpretOpenRead, [Arg("filename", TypeEnum.STRING)], return_type=TypeEnum.HANDLE)
+openread_func = Builtin("open-read", interpretOpenRead, [Arg("filename", TypeEnum.STRING)], return_type=Type(":handle"))
 openread_multi = MultiFunction("open-read")
 openread_multi.register(openread_func)
 FS.register("open-read", openread_multi)
@@ -81,7 +81,7 @@ def interpretOpenWrite(symbol, args, env, ns):
         raise InterpretPanic(symbol, "cannot open {fil} for writing")
     return Handle(f)
 
-openwrite_func = Builtin("open-write", interpretOpenWrite, [Arg("filename", TypeEnum.STRING)], return_type=TypeEnum.HANDLE)
+openwrite_func = Builtin("open-write", interpretOpenWrite, [Arg("filename", TypeEnum.STRING)], return_type=Type(":handle"))
 openwrite_multi = MultiFunction("open-write")
 openwrite_multi.register(openwrite_func)
 FS.register("open-write", openwrite_multi)
@@ -95,7 +95,7 @@ def interpretOpenAppend(symbol, args, env, ns):
         raise InterpretPanic(symbol, "cannot open {fil} for appending")
     return Handle(f)
 
-openappend_func = Builtin("open-append", interpretOpenAppend, [Arg("filename", TypeEnum.STRING)], return_type=TypeEnum.HANDLE)
+openappend_func = Builtin("open-append", interpretOpenAppend, [Arg("filename", TypeEnum.STRING)], return_type=Type(":handle"))
 openappend_multi = MultiFunction("open-append")
 openappend_multi.register(openappend_func)
 FS.register("open-append", openappend_multi)
@@ -126,7 +126,7 @@ def interpretRead(symbol, args, env, ns):
         raise InterpretPanic(symbol, f"{handle} is closed")
     return String(inp)
 
-read_func = Builtin("read", interpretRead, [Arg("handle", TypeEnum.HANDLE)], return_type=TypeEnum.STRING)
+read_func = Builtin("read", interpretRead, [Arg("handle", TypeEnum.HANDLE)], return_type=Type(":string"))
 read_multi = MultiFunction("read")
 read_multi.register(read_func)
 FS.register("read", read_multi)
@@ -141,7 +141,7 @@ def interpretReadLines(symbol, args, env, ns):
     out = List([String(d) for d in data]) # all lines are strings
     return out
 
-readlines_func = Builtin("read-lines", interpretReadLines, [Arg("filename", TypeEnum.STRING)], return_type=Type(":list"))
+readlines_func = Builtin("read-lines", interpretReadLines, [Arg("filename", TypeEnum.STRING)], return_type=Type(":[]"))
 readlines_multi = MultiFunction("read-lines")
 readlines_multi.register(readlines_func)
 FS.register("read-lines", readlines_multi)
diff --git a/neb/std/functools.py b/neb/std/functools.py
index 67ef728..5c3c2c6 100644
--- a/neb/std/functools.py
+++ b/neb/std/functools.py
@@ -17,7 +17,7 @@ def interpretFilter(symbol, args, env, ns):
             out.append(arg)
     return List(out)
 
-filter_func = Builtin("filter", interpretFilter, [Arg("func", TypeEnum.ANY), Arg("list", TypeEnum.LIST)], return_type=Type(":list"))
+filter_func = Builtin("filter", interpretFilter, [Arg("func", TypeEnum.ANY), Arg("list", TypeEnum.LIST)], return_type=Type(":[]"))
 filter_multi = MultiFunction("filter")
 filter_multi.register(filter_func)
 FUNCTOOLS.register("filter", filter_multi)
@@ -35,7 +35,7 @@ def interpretMap(symbol, args, env, ns):
         out.append(ev)
     return List(out)
 
-map_func = Builtin("map", interpretMap, [Arg("func", TypeEnum.ANY), Arg("list", TypeEnum.LIST)], return_type=Type(":list"))
+map_func = Builtin("map", interpretMap, [Arg("func", TypeEnum.ANY), Arg("list", TypeEnum.LIST)], return_type=Type(":[]"))
 map_multi = MultiFunction("map")
 map_multi.register(map_func)
 FUNCTOOLS.register("map", map_multi)
@@ -62,7 +62,7 @@ def interpretReduce(symbol, args, env, ns):
         ret = func.call(Expr([func, ret, arg]), env, ns)
     return ret
 
-reduce_func = Builtin("reduce", interpretReduce, [Arg("func", TypeEnum.ANY), Arg("list", TypeEnum.LIST), Arg("accum", TypeEnum.ANY)], return_type=Type(":list"))
+reduce_func = Builtin("reduce", interpretReduce, [Arg("func", TypeEnum.ANY), Arg("list", TypeEnum.LIST), Arg("accum", TypeEnum.ANY)])
 reduce_multi = MultiFunction("reduce")
 reduce_multi.register(reduce_func)
 FUNCTOOLS.register("reduce", reduce_multi)
diff --git a/neb/std/lists.py b/neb/std/lists.py
index ae5e56c..0ffa228 100644
--- a/neb/std/lists.py
+++ b/neb/std/lists.py
@@ -26,7 +26,7 @@ def interpretRest(symbol, args, env, ns):
     # TODO do we know it's not evaluated?
     return List(args[0].args[1:]) # we don't evaluate the remainder of the list
 
-rest_func = Builtin("rest", interpretRest, [Arg("arg", TypeEnum.LIST)], return_type=Type(":list"))
+rest_func = Builtin("rest", interpretRest, [Arg("arg", TypeEnum.LIST)], return_type=Type(":[]"))
 rest_multi = MultiFunction("rest")
 rest_multi.register(rest_func)
 LISTS.register("rest", rest_multi)
@@ -36,7 +36,7 @@ def interpretListReverse(symbol, args, env, ns):
     new_args.reverse()
     return List(new_args)
 
-reverse_func = Builtin("reverse", interpretListReverse, [Arg("list", TypeEnum.LIST)], return_type=Type(":list"))
+reverse_func = Builtin("reverse", interpretListReverse, [Arg("list", TypeEnum.LIST)], return_type=Type(":[]"))
 reverse_multi = MultiFunction("reverse")
 reverse_multi.register(reverse_func)
 LISTS.register("reverse", reverse_multi)
@@ -54,7 +54,7 @@ def interpretShuf(symbol, args, env, ns):
     random.shuffle(items)
     return List(items)
 
-shuf_func = Builtin("shuf", interpretShuf, [Arg("list", TypeEnum.LIST)], return_type=Type(":list"))
+shuf_func = Builtin("shuf", interpretShuf, [Arg("list", TypeEnum.LIST)], return_type=Type(":[]"))
 shuf_multi = MultiFunction("shuf")
 shuf_multi.register(shuf_func)
 LISTS.register("shuf", shuf_multi)
@@ -95,10 +95,9 @@ def interpretSlice(symbol, args, env, ns):
 
 slice_list_arg = Arg("list", TypeEnum.LIST)
 slice_idx_arg = Arg("idx", TypeEnum.INT)
-#slice_length_arg = Arg("length", TypeEnum.INT, optional=True)
 slice_length_arg = Arg("length", TypeEnum.INT)
-slice_nolength_func = Builtin("slice", interpretSlice, [slice_list_arg, slice_idx_arg], return_type=Type(":list"))
-slice_length_func = Builtin("slice", interpretSlice, [slice_list_arg, slice_idx_arg, slice_length_arg], return_type=Type(":list"))
+slice_nolength_func = Builtin("slice", interpretSlice, [slice_list_arg, slice_idx_arg], return_type=Type(":[]"))
+slice_length_func = Builtin("slice", interpretSlice, [slice_list_arg, slice_idx_arg, slice_length_arg], return_type=Type(":[]"))
 slice_multi = MultiFunction("slice")
 slice_multi.register(slice_nolength_func)
 slice_multi.register(slice_length_func)
@@ -110,7 +109,7 @@ def interpretAppend(symbol, args, env, ns):
     items = lst.args[:]
     return List(items + [val])
 
-append_func = Builtin("append", interpretAppend, [Arg("list", TypeEnum.LIST), Arg("item", TypeEnum.ANY)], return_type=Type(":list"))
+append_func = Builtin("append", interpretAppend, [Arg("list", TypeEnum.LIST), Arg("item", TypeEnum.ANY)], return_type=Type(":[]"))
 append_multi = MultiFunction("append")
 append_multi.register(append_func)
 LISTS.register("append", append_multi)
@@ -125,7 +124,7 @@ def interpretRemove(symbol, args, env, ns):
             out.append(arg)
     return List(out)
 
-remove_func = Builtin("remove", interpretRemove, [Arg("list", TypeEnum.LIST), Arg("key", TypeEnum.ANY)], return_type=Type(":list"))
+remove_func = Builtin("remove", interpretRemove, [Arg("list", TypeEnum.LIST), Arg("key", TypeEnum.ANY)], return_type=Type(":[]"))
 remove_multi = MultiFunction("remove")
 remove_multi.register(remove_func)
 LISTS.register("remove", remove_multi)
@@ -143,7 +142,7 @@ def interpretZip(symbol, args, env, ns):
     return List(out)
 
 zip_arg = Arg("list", TypeEnum.LIST)
-zip_func = Builtin("zip", interpretZip, [zip_arg, zip_arg], return_type=Type(":list"))
+zip_func = Builtin("zip", interpretZip, [zip_arg, zip_arg], return_type=Type(":[]"))
 zip_multi = MultiFunction("zip")
 zip_multi.register(zip_func)
 LISTS.register("zip", zip_multi)
@@ -151,7 +150,7 @@ LISTS.register("zip", zip_multi)
 def interpretList(symbol, args, env, ns):
     return List(args)
 
-list_func = Builtin("list", interpretList, [], Arg("item", TypeEnum.ANY), Type(":list"))
+list_func = Builtin("list", interpretList, [], Arg("item", TypeEnum.ANY), Type(":[]"))
 list_multi = MultiFunction("list")
 list_multi.register(list_func)
 LISTS.register("list", list_multi)
@@ -181,7 +180,7 @@ def interpretPrepend(symbol, args, env, ns):
     items = lst.args[:]
     return List([val] + items)
 
-prepend_func = Builtin("prepend", interpretPrepend, [Arg("list", TypeEnum.LIST), Arg("item", TypeEnum.ANY)], return_type=Type(":list"))
+prepend_func = Builtin("prepend", interpretPrepend, [Arg("list", TypeEnum.LIST), Arg("item", TypeEnum.ANY)], return_type=Type(":[]"))
 prepend_multi = MultiFunction("prepend")
 prepend_multi.register(prepend_func)
 LISTS.register("prepend", prepend_multi)
@@ -189,7 +188,7 @@ LISTS.register("prepend", prepend_multi)
 def interpretListMost(symbol, args, env, ns):
     return List(args[0].args[:-1])
 
-most_func = Builtin("most", interpretListMost, [Arg("list", TypeEnum.LIST)], return_type=Type(":list"))
+most_func = Builtin("most", interpretListMost, [Arg("list", TypeEnum.LIST)], return_type=Type(":[]"))
 most_multi = MultiFunction("most")
 most_multi.register(most_func)
 LISTS.register("most", most_multi)
diff --git a/neb/std/repl.py b/neb/std/repl.py
index 2979c5b..05bb68d 100644
--- a/neb/std/repl.py
+++ b/neb/std/repl.py
@@ -29,8 +29,8 @@ def interpretSymbols(symbol, args, env, ns):
         keys = [Symbol(k, -1, True) for k,v in sorted(env.get_all().items()) if not k.startswith(".")]
     return List(keys)
 
-symbols_nonhidden_func = Builtin("symbols", interpretSymbols, [], return_type=Type(":list"))
-symbols_all_func = Builtin("symbols", interpretSymbols, [Arg("all?", TypeEnum.BOOL)], return_type=Type(":list"))
+symbols_nonhidden_func = Builtin("symbols", interpretSymbols, [], return_type=Type(":[]"))
+symbols_all_func = Builtin("symbols", interpretSymbols, [Arg("all?", TypeEnum.BOOL)], return_type=Type(":[]"))
 symbols_multi = MultiFunction("symbols")
 symbols_multi.register(symbols_nonhidden_func)
 symbols_multi.register(symbols_all_func)
@@ -43,8 +43,8 @@ def interpretFuncs(symbol, args, env, ns):
         keys = [Symbol(k, -1, True) for k,v in sorted(env.get_all().items()) if isinstance(v, MultiFunction) and not k.startswith(".")]
     return List(keys)
 
-funcs_nonhidden_func = Builtin("funcs", interpretFuncs, [], return_type=Type(":list"))
-funcs_all_func = Builtin("funcs", interpretFuncs, [Arg("all?", TypeEnum.BOOL)], return_type=Type(":list"))
+funcs_nonhidden_func = Builtin("funcs", interpretFuncs, [], return_type=Type(":[]"))
+funcs_all_func = Builtin("funcs", interpretFuncs, [Arg("all?", TypeEnum.BOOL)], return_type=Type(":[]"))
 funcs_multi = MultiFunction("funcs")
 funcs_multi.register(funcs_nonhidden_func)
 funcs_multi.register(funcs_all_func)
@@ -57,8 +57,8 @@ def interpretUserSymbols(symbol, args, env, ns):
         keys = [Symbol(k, -1, True) for k,v in sorted(env.get_all().items()) if ((isinstance(v, MultiFunction) and v.user_impl()) or isinstance(v, Literal)) and not k.startswith(".")]
     return List(keys)
 
-usersymbols_nonhidden_func = Builtin("user-symbols", interpretUserSymbols, [], return_type=Type(":list"))
-usersymbols_all_func = Builtin("user-symbols", interpretUserSymbols, [Arg("all?", TypeEnum.BOOL)], return_type=Type(":list"))
+usersymbols_nonhidden_func = Builtin("user-symbols", interpretUserSymbols, [], return_type=Type(":[]"))
+usersymbols_all_func = Builtin("user-symbols", interpretUserSymbols, [Arg("all?", TypeEnum.BOOL)], return_type=Type(":[]"))
 usersymbols_multi = MultiFunction("user-symbols")
 usersymbols_multi.register(usersymbols_nonhidden_func)
 usersymbols_multi.register(usersymbols_all_func)
@@ -71,8 +71,8 @@ def interpretUserFuncs(symbol, args, env, ns):
         keys = [Symbol(k, -1, True) for k,v in sorted(env.get_all().items()) if isinstance(v, MultiFunction) and v.user_impl() and not k.startswith(".")]
     return List(keys)
 
-userfuncs_nonhidden_func = Builtin("user-funcs", interpretUserFuncs, [], return_type=Type(":list"))
-userfuncs_all_func = Builtin("user-funcs", interpretUserFuncs, [Arg("all?", TypeEnum.BOOL)], return_type=Type(":list"))
+userfuncs_nonhidden_func = Builtin("user-funcs", interpretUserFuncs, [], return_type=Type(":[]"))
+userfuncs_all_func = Builtin("user-funcs", interpretUserFuncs, [Arg("all?", TypeEnum.BOOL)], return_type=Type(":[]"))
 userfuncs_multi = MultiFunction("user-funcs")
 userfuncs_multi.register(userfuncs_nonhidden_func)
 userfuncs_multi.register(userfuncs_all_func)
@@ -82,7 +82,7 @@ def interpretSyntax(symbol, args, env, ns):
     keys = [Symbol(k, -1, True) for k,v in sorted(env.get_all().items()) if isinstance(v, NebSyntax)]
     return List(keys)
 
-syntax_func = Builtin("syntax", interpretSyntax, [], return_type=Type(":list"))
+syntax_func = Builtin("syntax", interpretSyntax, [], return_type=Type(":[]"))
 syntax_multi = MultiFunction("syntax")
 syntax_multi.register(syntax_func)
 REPL.register("syntax", syntax_multi)
diff --git a/neb/std/strings.py b/neb/std/strings.py
index 21bd0a3..7f6451e 100644
--- a/neb/std/strings.py
+++ b/neb/std/strings.py
@@ -31,8 +31,8 @@ def interpretSplit(symbol, args, env, ns):
     ret = target.value.split(splitter.value)
     return List([String(r) for r in ret])
 
-split_nosplitter_func = Builtin("split", interpretSplit, [Arg("target", TypeEnum.STRING)], return_type=Type(":list"))
-split_splitter_func = Builtin("split", interpretSplit, [Arg("target", TypeEnum.STRING), Arg("splitter", TypeEnum.STRING)], return_type=Type(":list"))
+split_nosplitter_func = Builtin("split", interpretSplit, [Arg("target", TypeEnum.STRING)], return_type=Type(":[]"))
+split_splitter_func = Builtin("split", interpretSplit, [Arg("target", TypeEnum.STRING), Arg("splitter", TypeEnum.STRING)], return_type=Type(":[]"))
 split_multi = MultiFunction("split")
 split_multi.register(split_nosplitter_func)
 split_multi.register(split_splitter_func)
diff --git a/neb/std/sys.py b/neb/std/sys.py
index 7ff5e56..dea06d8 100644
--- a/neb/std/sys.py
+++ b/neb/std/sys.py
@@ -14,7 +14,7 @@ def interpretArgv(symbol, args, env, ns):
         out.append(String(arg))
     return List(out)
 
-argv_func = Builtin("argv", interpretArgv, [], return_type=Type(":list"))
+argv_func = Builtin("argv", interpretArgv, [], return_type=Type(":[]"))
 argv_multi = MultiFunction("argv")
 argv_multi.register(argv_func)
 SYS.register("argv", argv_multi)
diff --git a/neb/std/term.py b/neb/std/term.py
index 3c82bcf..e83f261 100644
--- a/neb/std/term.py
+++ b/neb/std/term.py
@@ -7,9 +7,9 @@ TERM = Environment()
 
 def interpretClear(symbol, args, env, ns):
     subprocess.run(["clear"])
-    return List([])
+    return Nil()
 
-clear_func = Builtin("clear", interpretClear, [], return_type=Type(":list"))
+clear_func = Builtin("clear", interpretClear, [], return_type=Type(":nil"))
 clear_multi = MultiFunction("clear")
 clear_multi.register(clear_func)
 TERM.register("clear", clear_multi)
diff --git a/neb/std/types.py b/neb/std/types.py
index 20aa27a..cd899bc 100644
--- a/neb/std/types.py
+++ b/neb/std/types.py
@@ -137,7 +137,7 @@ TYPES.register("->string", tostring_multi)
 def interpretTypeOf(symbol, args, env, ns):
     return Type(f"{args[0].type_}")
 
-typeof_func = Builtin("typeof", interpretTypeOf, [Arg("candidate", TypeEnum.ANY)])
+typeof_func = Builtin("typeof", interpretTypeOf, [Arg("candidate", TypeEnum.ANY)], return_type=Type(":type"))
 typeof_multi = MultiFunction("typeof")
 typeof_multi.register(typeof_func)
 TYPES.register("typeof", typeof_multi)