give builtin functions proper names

1 files changed, 30 insertions, 14 deletions

diff --git a/neb/std/lists.py b/neb/std/lists.py
index d5c18c2..5aaab53 100644
--- a/neb/std/lists.py
+++ b/neb/std/lists.py
@@ -1,4 +1,4 @@
-from .. import TypeEnum, Environment, Arg, Builtin, evaluate
+from .. import TypeEnum, Environment, Arg, Builtin, evaluate, InterpretPanic
 from ..structs import *
 import random
 
@@ -7,39 +7,39 @@ LISTS = Environment()
 def interpretListLength(symbol, args, env, ns):
     return Int(len(args[0].args))
 
-LISTS.register("list-length", Builtin(interpretListLength, [Arg("arg", TypeEnum.LIST)]))
+LISTS.register("list-length", Builtin("list-length", interpretListLength, [Arg("arg", TypeEnum.LIST)]))
     
 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(interpretFirst, [Arg("arg", TypeEnum.LIST, )]))
+LISTS.register("first", Builtin("first", interpretFirst, [Arg("arg", TypeEnum.LIST, )]))
 
 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(interpretRest, [Arg("arg", TypeEnum.LIST)]))
+LISTS.register("rest", Builtin("rest", interpretRest, [Arg("arg", TypeEnum.LIST)]))
 
 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(interpretListReverse, [Arg("list", TypeEnum.LIST)]))
+LISTS.register("list-reverse", Builtin("list-reverse", interpretListReverse, [Arg("list", TypeEnum.LIST)]))
 
 def interpretEmpty(symbol, args, env, ns):
     return Bool(len(args[0].args) == 0)
 
-LISTS.register("empty?", Builtin(interpretEmpty, [Arg("list", TypeEnum.LIST)]))
+LISTS.register("empty?", Builtin("empty?", interpretEmpty, [Arg("list", TypeEnum.LIST)]))
 
 def interpretShuf(symbol, args, env, ns):
     items = args[0].args[:]
     random.shuffle(items)
     return List(items)
 
-LISTS.register("shuf", Builtin(interpretShuf, [Arg("list", TypeEnum.LIST)]))
+LISTS.register("shuf", Builtin("shuf", interpretShuf, [Arg("list", TypeEnum.LIST)]))
 
 def interpretIn(symbol, args, env, ns):
     target = args[0]
@@ -51,14 +51,14 @@ def interpretIn(symbol, args, env, ns):
 
 in_target_arg = Arg("target", TypeEnum.LITERAL)
 in_list_arg = Arg("list", TypeEnum.LIST)
-LISTS.register("in?", Builtin(interpretIn, [in_target_arg, in_list_arg]))
+LISTS.register("in?", Builtin("in?", interpretIn, [in_target_arg, in_list_arg]))
 
 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(interpretLast, [Arg("list", TypeEnum.LIST)]))
+LISTS.register("last", Builtin("last", interpretLast, [Arg("list", TypeEnum.LIST)]))
 
 def interpretSlice(symbol, args, env, ns):
     lst = args[0]
@@ -72,7 +72,7 @@ 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(interpretSlice, [slice_list_arg, slice_idx_arg, slice_length_arg]))
+LISTS.register("slice", Builtin("slice", interpretSlice, [slice_list_arg, slice_idx_arg, slice_length_arg]))
 
 def interpretAppend(symbol, args, env, ns):
     lst = args[0]
@@ -80,7 +80,7 @@ def interpretAppend(symbol, args, env, ns):
     items = lst.args[:]
     return List(items + [val])
 
-LISTS.register("append", Builtin(interpretAppend, [Arg("list", TypeEnum.LIST), Arg("item", TypeEnum.ANY)]))
+LISTS.register("append", Builtin("append", interpretAppend, [Arg("list", TypeEnum.LIST), Arg("item", TypeEnum.ANY)]))
 
 # TODO: this is actually for records/structs/whatever they're called
 def interpretRemove(symbol, args, env, ns):
@@ -92,7 +92,7 @@ def interpretRemove(symbol, args, env, ns):
             out.append(arg)
     return List(out)
 
-LISTS.register("remove", Builtin(interpretRemove, [Arg("list", TypeEnum.LIST), Arg("key", TypeEnum.ANY)]))
+LISTS.register("remove", Builtin("remove", interpretRemove, [Arg("list", TypeEnum.LIST), Arg("key", TypeEnum.ANY)]))
 
 def interpretZip(symbol, args, env, ns):
     z1 = args[0]
@@ -107,10 +107,26 @@ def interpretZip(symbol, args, env, ns):
     return List(out)
 
 zip_arg = Arg("list", TypeEnum.LIST)
-LISTS.register("zip", Builtin(interpretZip, [zip_arg, zip_arg]))
+LISTS.register("zip", Builtin("zip", interpretZip, [zip_arg, zip_arg]))
 
 def interpretList(symbol, args, env, ns):
     return List(args)
 
-LISTS.register("list", Builtin(interpretList, [], Arg("item", TypeEnum.ANY)))
+LISTS.register("list", Builtin("list", interpretList, [], Arg("item", TypeEnum.ANY)))
 
+def interpretSortNumbers(symbol, args, env, ns):
+    items = []
+    for arg in args[0].args:
+        if not isinstance(arg, Int) and not isinstance(arg, Float):
+            raise InterpretPanic(symbol, "requires all :numbers", arg)
+        items.append(arg.value)
+    items.sort()
+    out = []
+    for item in items:
+        if isinstance(item, int):
+            out.append(Int(item))
+        else:
+            out.append(Float(item))
+    return List(out)
+
+LISTS.register("sort-numbers", Builtin("sort-numbers", interpretSortNumbers, [Arg("list", TypeEnum.LIST)]))