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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
from .lexer import lex
from .parser import parse
from .exceptions import *
from .typeclass import TypeEnum, is_subtype_of
from .structs import *
def interpret(exprs, env, ns=None):
ret = None
for expr in exprs:
ret = evaluate(expr, env, ns)
return ret
def evaluate(expr, env, ns=None):
if isinstance(expr, Literal) or isinstance(expr, Function) or isinstance(expr, Type):
return expr
elif isinstance(expr, Symbol):
if env.contains(expr.name):
return evaluate(env.get(expr.name), env, ns)
elif ns is not None and env.contains(f"{ns}/{expr.name}"):
return evaluate(env.get(f"{ns}/{expr.name}"), env, ns)
else:
raise NebPanic(f"no such symbol: {expr}")
# if it's an empty list, return it
elif len(expr.args) == 0:
return expr
if not isinstance(expr.args[0], Symbol):
raise NebPanic("can't evaluate without a symbol")
name = expr.args[0].name
if env.contains(name):
return env.get(name).call(expr, env, ns)
elif ns is not None and env.contains(f"{ns}/{name}"):
return env.get(f"{ns}/{name}").call(expr, env, ns)
else:
raise InterpretPanic(expr.args[0], "unable to evaluate")
class Function:
def __init__(self, name, params, body, args=None, many=None):
self.name = name
self.params = params
self.body = body
self.args = args
self.many = many
self.type_ = TypeEnum.ANY # TODO no it's not
def describe(self, name=None):
if name is None:
name = self.name
out = [f"({name}"]
out.append(string_args(self.args, self.many))
return " ".join(out).strip() + ")"
def arity_check(self, symbol, params):
min_arity = len([a for a in self.args if not a.optional])
max_arity = -1 if self.many is not None else len(self.args)
if len(params) < min_arity or (max_arity >= 0 and len(params) > max_arity):
if max_arity < 0:
fmt = f"{min_arity}+"
elif min_arity != max_arity:
fmt = f"{min_arity}-{max_arity}"
else:
fmt = f"{min_arity}"
raise InterpretPanic(symbol, f"expected [{fmt}] arguments, received {len(params)}")
return True
def evaluate_args(self, symbol, params, env, ns):
self.arity_check(symbol, params)
ret = []
for idx, param in enumerate(params):
if idx < len(self.args):
arg = self.args[idx]
else:
arg = self.many
if arg.lazy:
ret.append(param)
continue
ev = evaluate(param, env, ns)
if not is_subtype_of(ev.type_, arg.type_):
exp = f"{arg.type_}"
rec = f"{ev.type_}"
raise InterpretPanic(symbol, f"received {rec}, expected {exp}", ev)
ret.append(ev)
return ret
def call(self, expr, env):
pass
class Builtin(Function):
def __init__(self, name, callable_, args=None, many=None):
super().__init__(name, None, callable_, args, many)
def __str__(self):
return f"builtin function {self.name}"
def call(self, expr, env, ns):
self.arity_check(expr.args[0], expr.args[1:])
evaluated_args = self.evaluate_args(expr.args[0], expr.args[1:], env, ns)
return self.body(expr.args[0], evaluated_args, env, ns)
class UserFunction(Function):
def __init__(self, name, params, body):
newparams, args, many = self.process_params(name, params)
super().__init__(name, newparams, body, args, many)
def __str__(self):
out = f"(func {self.name} ("
args_list = [f"{a.name} {a.type_}" for a in self.args]
if self.many:
args_list.append(f"{self.many.name} {self.many.type_}")
out = out + " ".join(args_list) + ") "
for expr in self.body:
out = out + f"{expr} "
return out.strip() + ")"
def process_params(self, name, params):
newparams = []
args = []
many = None
prev_type = False
first = True
for param in params:
if isinstance(param, Symbol):
if many is not None:
raise NebPanic("& must be last argument")
if param.name == "&":
many = Arg(param.name, TypeEnum.ANY)
else:
newparams.append(param)
args.append(Arg(param.name, TypeEnum.ANY))
prev_type = False
elif isinstance(param, Type) and not prev_type and not first:
typ = TypeEnum.__getattr__(param.name[1:].upper())
if many is None:
args[-1].type_ = typ
else:
many.type_ = typ
prev_type = True
else:
raise NebPanic("invalid :func signature", param)
first = False
return newparams, args, many
def call(self, expr, env, ns):
self.arity_check(expr.args[0], expr.args[1:])
evaluated_args = self.evaluate_args(expr.args[0], expr.args[1:], env, ns)
this_env = Environment(env)
for idx, param in enumerate(self.params):
this_env.register(param.name, evaluated_args[idx])
# if we got "many", wrap the rest in a list
if self.many:
this_env.register(self.many.name, List(evaluated_args[len(self.params):]))
return interpret(self.body, env=this_env, ns=ns)
|
