1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
from .. import TypeEnum, Environment, Arg, Builtin, evaluate, InterpretPanic, NebType, TypeWrap
from ..structs import *
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")))
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")))
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")))
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")))
def interpretIsList(symbol, args, env, ns):
# if it's not a list, we're done
if not (isinstance(args[0], List) or isinstance(args[0], Expr)):
return Bool(False)
# if the symbol isn't a type, we're done
elif not isinstance(symbol, Type):
return Bool(True)
inner = symbol.inner
if inner is None or inner.name == ":any":
return Bool(True)
inner_type = env.get(f"{inner.name}")
for arg in args[0].args:
valid = inner_type.validate_type(arg, env, ns)
if valid.value is False:
return Bool(False)
return Bool(True)
TYPES.register("list?", Builtin("list?", interpretIsList, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool")))
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")))
def interpretStringToInt(symbol, args, env, ns):
try:
val = int(args[0].value)
return Int(val)
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")))
def interpretToString(symbol, args, env, ns):
item = args[0]
if isinstance(item, String):
return item
elif isinstance(item, Literal):
return String(str(item))
else:
return String(f"{item}")
TYPES.register("->string", Builtin("->string", interpretToString, [Arg("arg", TypeEnum.ANY)], return_type=Type(":string")))
def interpretTypeOf(symbol, args, env, ns):
return Type(f"{args[0].type_}")
TYPES.register("typeof", Builtin("typeof", interpretTypeOf, [Arg("candidate", TypeEnum.ANY)]))
def interpretIsAny(symbol, args, env, ns):
return Bool(True)
TYPES.register("any?", Builtin("any?", interpretIsAny, [Arg("arg", TypeEnum.ANY)], return_type=Type(":bool")))
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")))
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")))
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")))
# add types to env
any_type = NebType(":any", None, interpretIsAny)
literal_type = NebType(":literal", any_type, interpretIsLiteral)
string_type = NebType(":string", literal_type, interpretIsString)
#list_type = NebType(":list", any_type, interpretIsList)
bracket_type = NebType(":[]", any_type, interpretIsList)
bool_type = NebType(":bool", literal_type, interpretIsBool)
number_type = NebType(":number", literal_type, interpretIsNumber)
int_type = NebType(":int", number_type, interpretIsInt)
float_type = NebType(":float", number_type, interpretIsFloat)
handle_type = NebType(":handle", any_type, interpretIsHandle)
type_type = NebType(":type", any_type, interpretIsType)
TYPES.register(":any", any_type)
TYPES.register(":literal", literal_type)
TYPES.register(":string", string_type)
#TYPES.register(":list", list_type)
TYPES.register(":[]", bracket_type)
TYPES.register(":bool", bool_type)
TYPES.register(":number", number_type)
TYPES.register(":int", int_type)
TYPES.register(":float", float_type)
TYPES.register(":handle", handle_type)
TYPES.register(":type", type_type)
|
