implement multifunc for types

1 files changed, 48 insertions, 13 deletions

diff --git a/neb/std/types.py b/neb/std/types.py
index 999b2c2..7e77597 100644
--- a/neb/std/types.py
+++ b/neb/std/types.py
@@ -6,23 +6,35 @@ TYPES = Environment()
 def interpretIsBool(symbol, args, env, ns):
     return Bool(isinstance(args[0], Bool))
 
-TYPES.register("bool?", Builtin("bool?", interpretIsBool, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool")))
+isbool_func = Builtin("bool?", interpretIsBool, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool"))
+isbool_multi = MultiFunction("bool?")
+isbool_multi.register(isbool_func)
+TYPES.register("bool?", isbool_multi)
 
 def interpretIsFloat(symbol, args, env, ns):
     return Bool(isinstance(args[0], Float))
 
-TYPES.register("float?", Builtin("float?", interpretIsFloat, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool")))
+isfloat_func = Builtin("float?", interpretIsFloat, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool"))
+isfloat_multi = MultiFunction("float?")
+isfloat_multi.register(isfloat_func)
+TYPES.register("float?", isfloat_multi)
 
 def interpretIsNumber(symbol, args, env, ns):
     ret = isinstance(args[0], Int) or isinstance(args[0], Float)
     return Bool(ret)
 
-TYPES.register("number?", Builtin("number?", interpretIsNumber, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool")))
+isnumber_func = Builtin("number?", interpretIsNumber, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool"))
+isnumber_multi = MultiFunction("number?")
+isnumber_multi.register(isnumber_func)
+TYPES.register("number?", isnumber_multi)
 
 def interpretIsInt(symbol, args, env, ns):
     return Bool(isinstance(args[0], Int))
 
-TYPES.register("int?", Builtin("int?", interpretIsInt, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool")))
+isint_func = Builtin("int?", interpretIsInt, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool"))
+isint_multi = MultiFunction("int?")
+isint_multi.register(isint_func)
+TYPES.register("int?", isint_multi)
 
 def interpretIsList(symbol, args, env, ns):
 
@@ -45,13 +57,18 @@ def interpretIsList(symbol, args, env, ns):
             return Bool(False)
     return Bool(True)
 
-
-TYPES.register("list?", Builtin("list?", interpretIsList, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool")))
+islist_func = Builtin("list?", interpretIsList, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool"))
+islist_multi = MultiFunction("list?")
+islist_multi.register(islist_func)
+TYPES.register("list?", islist_multi)
 
 def interpretIsString(symbol, args, env, ns):
     return Bool(isinstance(args[0], String))
 
-TYPES.register("string?", Builtin("string?", interpretIsString, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool")))
+isstring_func = Builtin("string?", interpretIsString, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool"))
+isstring_multi = MultiFunction("string?")
+isstring_multi.register(isstring_func)
+TYPES.register("string?", isstring_multi)
 
 def interpretStringToInt(symbol, args, env, ns):
     try:
@@ -60,7 +77,10 @@ def interpretStringToInt(symbol, args, env, ns):
     except:
         raise InterpretPanic(symbol, "can't convert to an :int", args[0])
 
-TYPES.register("string->int", Builtin("string->int", interpretStringToInt, [Arg("arg", TypeEnum.STRING)], return_type=Type(":int")))
+stringtoint_func = Builtin("string->int", interpretStringToInt, [Arg("arg", TypeEnum.STRING)], return_type=Type(":int"))
+stringtoint_multi = MultiFunction("string->int")
+stringtoint_multi.register(stringtoint_func)
+TYPES.register("string->int", stringtoint_multi)
 
 def interpretToString(symbol, args, env, ns):
     item = args[0]
@@ -79,27 +99,42 @@ TYPES.register("->string", tostring_multi)
 def interpretTypeOf(symbol, args, env, ns):
     return Type(f"{args[0].type_}")
 
-TYPES.register("typeof", Builtin("typeof", interpretTypeOf, [Arg("candidate", TypeEnum.ANY)]))
+typeof_func = Builtin("typeof", interpretTypeOf, [Arg("candidate", TypeEnum.ANY)])
+typeof_multi = MultiFunction("typeof")
+typeof_multi.register(typeof_func)
+TYPES.register("typeof", typeof_multi)
 
 def interpretIsAny(symbol, args, env, ns):
     return Bool(True)
 
-TYPES.register("any?", Builtin("any?", interpretIsAny, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool")))
+isany_func = Builtin("any?", interpretIsAny, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool"))
+isany_multi = MultiFunction("any?")
+isany_multi.register(isany_func)
+TYPES.register("any?", isany_multi)
 
 def interpretIsLiteral(symbol, args, env, ns):
     return Bool(isinstance(args[0], Literal))
 
-TYPES.register("literal?", Builtin("literal?", interpretIsLiteral, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool")))
+isliteral_func = Builtin("literal?", interpretIsLiteral, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool"))
+isliteral_multi = MultiFunction("literal?")
+isliteral_multi.register(isliteral_func)
+TYPES.register("literal?", isliteral_multi)
 
 def interpretIsHandle(symbol, args, env, ns):
     return Bool(isinstance(args[0], Handle))
 
-TYPES.register("handle?", Builtin("handle?", interpretIsHandle, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool")))
+ishandle_func = Builtin("handle?", interpretIsHandle, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool"))
+ishandle_multi = MultiFunction("handle?")
+ishandle_multi.register(ishandle_func)
+TYPES.register("handle?", ishandle_multi)
 
 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")))
+istype_func = Builtin("type?", interpretIsType, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool"))
+istype_multi = MultiFunction("type?")
+istype_multi.register(istype_func)
+TYPES.register("type?", istype_multi)
 
 # add types to env
 any_type = NebType(":any", None, interpretIsAny)