From ac7a6c08ebba80c6c5d8b4d8ce79d06a6c86d9ee Mon Sep 17 00:00:00 2001 From: mryouse Date: Wed, 3 Aug 2022 01:20:59 +0000 Subject: bugfix: :[] return types in std --- neb/std/fs.py | 10 +++++----- neb/std/functools.py | 6 +++--- neb/std/lists.py | 23 +++++++++++------------ neb/std/repl.py | 18 +++++++++--------- neb/std/strings.py | 4 ++-- neb/std/sys.py | 2 +- neb/std/term.py | 4 ++-- neb/std/types.py | 2 +- 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) -- cgit v1.2.3