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
|
from .. import TypeEnum, Environment, Arg, Builtin, evaluate, InterpretPanic, MultiFunction
from ..structs import *
STRINGS = Environment()
def interpretConcat(symbol, args, env, ns):
out = ""
for arg in args:
out += arg.value
return String(out)
string_arg = Arg("arg", TypeEnum.STRING)
concat_func = Builtin("concat", interpretConcat, [string_arg, string_arg], string_arg, Type(":string"))
concat_multi = MultiFunction("concat")
concat_multi.register(concat_func)
STRINGS.register("concat", concat_multi)
def interpretStrip(symbol, args, env, ns):
return String(args[0].value.strip())
strip_func = Builtin("strip", interpretStrip, [Arg("filename", TypeEnum.STRING)], return_type=Type(":string"))
strip_multi = MultiFunction("strip")
strip_multi.register(strip_func)
STRINGS.register("strip", strip_multi)
def interpretSplit(symbol, args, env, ns):
target = args[0]
if len(args) == 1:
return List([String(char) for char in target.value])
splitter = args[1]
ret = target.value.split(splitter.value)
return List([String(r) for r in ret])
split_nosplitter_func = Builtin("split", interpretSplit, [Arg("target", TypeEnum.STRING)], return_type=Type(":list"))
split_splitter_func = Builtin("split", interpretSplit, [Arg("target", TypeEnum.STRING), Arg("splitter", TypeEnum.STRING)], return_type=Type(":list"))
split_multi = MultiFunction("split")
split_multi.register(split_nosplitter_func)
split_multi.register(split_splitter_func)
STRINGS.register("split", split_multi)
def interpretJoin(symbol, args, env, ns):
lst = args[0]
target = args[1]
return String(target.value.join([a.value for a in lst.args]))
join_list_arg = Arg("list", TypeEnum.LIST)
join_string_arg = Arg("joiner", TypeEnum.STRING)
join_func = Builtin("join", interpretJoin, [join_list_arg, join_string_arg], return_type=Type(":string"))
join_multi = MultiFunction("join")
join_multi.register(join_func)
STRINGS.register("join", join_multi)
def interpretFirstChar(symbol, args, env, ns):
if len(args[0].value) == 0:
raise InterpretPanic(symbol, ":string is empty")
return String(args[0].value[0])
firstchar_func = Builtin("first", interpretFirstChar, [Arg("string", TypeEnum.STRING)], return_type=Type(":string"))
firstchar_multi = MultiFunction("first")
firstchar_multi.register(firstchar_func)
STRINGS.register("first", firstchar_multi)
def interpretRestChar(symbol, args, env, ns):
return String(args[0].value[1:])
restchar_func = Builtin("rest", interpretRestChar, [Arg("string", TypeEnum.STRING)], return_type=Type(":string"))
restchar_multi = MultiFunction("rest")
restchar_multi.register(restchar_func)
STRINGS.register("rest", restchar_multi)
def interpretLength(symbol, args, env, ns):
return Int(len(args[0].value))
length_func = Builtin("length", interpretLength, [Arg("string", TypeEnum.STRING)], return_type=Type(":int"))
length_multi = MultiFunction("length")
length_multi.register(length_func)
STRINGS.register("length", length_multi)
def interpretRaw(symbol, args, env, ns):
return String(str(args[0]))
raw_func = Builtin("raw", interpretRaw, [Arg("string", TypeEnum.STRING)], return_type=Type(":string"))
raw_multi = MultiFunction("raw")
raw_multi.register(raw_func)
STRINGS.register("raw", raw_multi)
def interpretOrd(symbol, args, env, ns):
if len(args[0].value) != 1:
raise InterpretPanic(symbol, "requires a :string of length 1", args[0])
return Int(ord(args[0].value))
ord_func = Builtin("ord", interpretOrd, [Arg("char", TypeEnum.STRING)], return_type=Type(":int"))
ord_multi = MultiFunction("ord")
ord_multi.register(ord_func)
STRINGS.register("ord", ord_multi)
def interpretStringReverse(symbol, args, env, ns):
return String(args[0].value[::-1])
string_reverse_func = Builtin("reverse", interpretStringReverse, [Arg("str", TypeEnum.STRING)], return_type=Type(":string"))
string_reverse_multi = MultiFunction("reverse")
string_reverse_multi.register(string_reverse_func)
STRINGS.register("reverse", string_reverse_multi)
def interpretStringLast(symbol, args, env, ns):
if len(args[0].value) == 0:
raise InterpretPanic(symbol, "string is empty")
return String(args[0].value[-1])
string_last_func = Builtin("last", interpretStringLast, [Arg("string", TypeEnum.STRING)], return_type=Type(":string"))
string_last_multi = MultiFunction("last")
string_last_multi.register(string_last_func)
STRINGS.register("last", string_last_multi)
def interpretStringMost(symbol, args, env, ns):
return String(args[0].value[:-1])
string_most_func = Builtin("most", interpretStringMost, [Arg("string", TypeEnum.STRING)], return_type=Type(":string"))
string_most_multi = MultiFunction("most")
string_most_multi.register(string_most_func)
STRINGS.register("most", string_most_multi)
|
