WIP implement multifunc for lists

1 files changed, 63 insertions, 16 deletions

diff --git a/neb/std/lists.py b/neb/std/lists.py
index a49962b..57d353e 100644
--- a/neb/std/lists.py
+++ b/neb/std/lists.py
@@ -1,4 +1,4 @@
-from .. import TypeEnum, Environment, Arg, Builtin, evaluate, InterpretPanic
+from .. import TypeEnum, Environment, Arg, Builtin, evaluate, InterpretPanic, NebSyntax, MultiFunction
 from ..structs import *
 import random
 
@@ -7,39 +7,57 @@ LISTS = Environment()
 def interpretListLength(symbol, args, env, ns):
     return Int(len(args[0].args))
 
-LISTS.register("list-length", Builtin("list-length", interpretListLength, [Arg("arg", TypeEnum.LIST)], return_type=Type(":int")))
+length_func = Builtin("length", interpretListLength, [Arg("arg", TypeEnum.LIST)], return_type=Type(":int"))
+length_multi = MultiFunction("length")
+length_multi.register(length_func)
+LISTS.register("length", length_multi)
     
 def interpretFirst(symbol, args, env, ns):
     if len(args[0].args) == 0:
         raise InterpretPanic(symbol, "list is empty")
     return evaluate(args[0].args[0], env, ns)
 
-LISTS.register("first", Builtin("first", interpretFirst, [Arg("arg", TypeEnum.LIST, )]))
+first_func = Builtin("first", interpretFirst, [Arg("arg", TypeEnum.LIST)])
+first_multi = MultiFunction("first")
+first_multi.register(first_func)
+LISTS.register("first", first_multi)
 
 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
 
-LISTS.register("rest", Builtin("rest", interpretRest, [Arg("arg", TypeEnum.LIST)], return_type=Type(":list")))
+rest_func = Builtin("rest", interpretRest, [Arg("arg", TypeEnum.LIST)], return_type=Type(":list"))
+rest_multi = MultiFunction("rest")
+rest_multi.register(rest_func)
+LISTS.register("rest", rest_multi)
 
 def interpretListReverse(symbol, args, env, ns):
     new_args = args[0].args[:] # make a copy of the args
     new_args.reverse()
     return List(new_args)
 
-LISTS.register("list-reverse", Builtin("list-reverse", interpretListReverse, [Arg("list", TypeEnum.LIST)], return_type=Type(":list")))
+reverse_func = Builtin("reverse", interpretListReverse, [Arg("list", TypeEnum.LIST)], return_type=Type(":list"))
+reverse_multi = MultiFunction("reverse")
+reverse_multi.register(reverse_func)
+LISTS.register("reverse", reverse_multi)
 
 def interpretEmpty(symbol, args, env, ns):
     return Bool(len(args[0].args) == 0)
 
-LISTS.register("empty?", Builtin("empty?", interpretEmpty, [Arg("list", TypeEnum.LIST)], return_type=Type(":bool")))
+empty_func = Builtin("empty?", interpretEmpty, [Arg("list", TypeEnum.LIST)], return_type=Type(":bool"))
+empty_multi = MultiFunction("empty")
+empty_multi.register(empty_func)
+LISTS.register("empty?", empty_multi)
 
 def interpretShuf(symbol, args, env, ns):
     items = args[0].args[:]
     random.shuffle(items)
     return List(items)
 
-LISTS.register("shuf", Builtin("shuf", interpretShuf, [Arg("list", TypeEnum.LIST)], return_type=Type(":list")))
+shuf_func = Builtin("shuf", interpretShuf, [Arg("list", TypeEnum.LIST)], return_type=Type(":list"))
+shuf_multi = MultiFunction("shuf")
+shuf_multi.register(shuf_func)
+LISTS.register("shuf", shuf_multi)
 
 def interpretIn(symbol, args, env, ns):
     target = args[0]
@@ -51,14 +69,20 @@ def interpretIn(symbol, args, env, ns):
 
 in_target_arg = Arg("target", TypeEnum.LITERAL)
 in_list_arg = Arg("list", TypeEnum.LIST)
-LISTS.register("in?", Builtin("in?", interpretIn, [in_target_arg, in_list_arg], return_type=Type(":bool")))
+in_func = Builtin("in?", interpretIn, [in_target_arg, in_list_arg], return_type=Type(":bool"))
+in_multi = MultiFunction("in?")
+in_multi.register(in_func)
+LISTS.register("in?", in_multi)
 
 def interpretLast(symbol, args, env, ns):
     if len(args[0].args) == 0:
         raise InterpretPanic("List is empty")
     return evaluate(args[0].args[-1], env, ns)
 
-LISTS.register("last", Builtin("last", interpretLast, [Arg("list", TypeEnum.LIST)]))
+last_func = Builtin("last", interpretLast, [Arg("list", TypeEnum.LIST)])
+last_multi = MultiFunction("last")
+last_multi.register(last_func)
+LISTS.register("last", last_multi)
 
 def interpretSlice(symbol, args, env, ns):
     lst = args[0]
@@ -71,8 +95,14 @@ 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)
-LISTS.register("slice", Builtin("slice", interpretSlice, [slice_list_arg, slice_idx_arg, slice_length_arg], return_type=Type(":list")))
+#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_multi = MultiFunction("slice")
+slice_multi.register(slice_nolength_func)
+slice_multi.register(slice_length_func)
+LISTS.register("slice", slice_multi)
 
 def interpretAppend(symbol, args, env, ns):
     lst = args[0]
@@ -80,7 +110,10 @@ def interpretAppend(symbol, args, env, ns):
     items = lst.args[:]
     return List(items + [val])
 
-LISTS.register("append", 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(":list"))
+append_multi = MultiFunction("append")
+append_multi.register(append_func)
+LISTS.register("append", append_multi)
 
 # TODO: this is actually for records/structs/whatever they're called
 def interpretRemove(symbol, args, env, ns):
@@ -92,7 +125,10 @@ def interpretRemove(symbol, args, env, ns):
             out.append(arg)
     return List(out)
 
-LISTS.register("remove", 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(":list"))
+remove_multi = MultiFunction("remove")
+remove_multi.register(remove_func)
+LISTS.register("remove", remove_multi)
 
 def interpretZip(symbol, args, env, ns):
     z1 = args[0]
@@ -107,13 +143,20 @@ def interpretZip(symbol, args, env, ns):
     return List(out)
 
 zip_arg = Arg("list", TypeEnum.LIST)
-LISTS.register("zip", Builtin("zip", interpretZip, [zip_arg, zip_arg], return_type=Type(":list")))
+zip_func = Builtin("zip", interpretZip, [zip_arg, zip_arg], return_type=Type(":list"))
+zip_multi = MultiFunction("zip")
+zip_multi.register(zip_func)
+LISTS.register("zip", zip_multi)
 
 def interpretList(symbol, args, env, ns):
     return List(args)
 
-LISTS.register("list", Builtin("list", interpretList, [], Arg("item", TypeEnum.ANY), Type(":list")))
+list_func = Builtin("list", interpretList, [], Arg("item", TypeEnum.ANY), Type(":list"))
+list_multi = MultiFunction("list")
+list_multi.register(list_func)
+LISTS.register("list", list_multi)
 
+'''
 def interpretSortNumbers(symbol, args, env, ns):
     items = []
     for arg in args[0].args:
@@ -130,6 +173,7 @@ def interpretSortNumbers(symbol, args, env, ns):
     return List(out)
 
 LISTS.register("sort-numbers", Builtin("sort-numbers", interpretSortNumbers, [Arg("list", TypeEnum.LIST)], return_type=Type(":list")))
+'''
 
 def interpretPrepend(symbol, args, env, ns):
     lst = args[0]
@@ -137,4 +181,7 @@ def interpretPrepend(symbol, args, env, ns):
     items = lst.args[:]
     return List([val] + items)
 
-LISTS.register("prepend", 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(":list"))
+prepend_multi = MultiFunction("prepend")
+prepend_multi.register(prepend_func)
+LISTS.register("prepend", prepend_multi)