mirror of
https://github.com/kanaka/mal.git
synced 2024-09-20 10:07:45 +03:00
118 lines
3.6 KiB
Io
118 lines
3.6 KiB
Io
MalTypes
|
|
MalReader
|
|
|
|
READ := method(str, MalReader read_str(str))
|
|
|
|
isPair := method(obj,
|
|
obj ?isSequential and(obj isEmpty not)
|
|
)
|
|
|
|
quasiquote := method(ast,
|
|
if(isPair(ast) not, return(MalList with(list(MalSymbol with("quote"), ast))))
|
|
a0 := ast at(0)
|
|
if(a0 == MalSymbol with("unquote"), return(ast at(1)))
|
|
if(isPair(a0) and (a0 at(0) == MalSymbol with("splice-unquote")),
|
|
return(MalList with(list(MalSymbol with("concat"), a0 at(1), quasiquote(ast rest)))),
|
|
return(MalList with(list(MalSymbol with("cons"), quasiquote(a0), quasiquote(ast rest)))))
|
|
)
|
|
|
|
eval_ast := method(ast, env,
|
|
(ast type) switch(
|
|
"MalSymbol", env get(ast),
|
|
"MalList", MalList with(ast map(a, EVAL(a, env))),
|
|
"MalVector", MalVector with(ast map(a, EVAL(a, env))),
|
|
"MalMap",
|
|
m := MalMap clone
|
|
ast foreach(k, v,
|
|
keyObj := MalMap keyToObj(k)
|
|
m atPut(MalMap objToKey(EVAL(keyObj, env)), EVAL(v, env))
|
|
)
|
|
m,
|
|
ast
|
|
)
|
|
)
|
|
|
|
EVAL := method(ast, env,
|
|
loop(
|
|
if(ast type != "MalList", return(eval_ast(ast, env)))
|
|
if(ast isEmpty, return ast)
|
|
if(ast at(0) type == "MalSymbol",
|
|
ast at(0) val switch(
|
|
"def!",
|
|
return(env set(ast at(1), EVAL(ast at(2), env))),
|
|
"do",
|
|
eval_ast(ast slice(1,-1), env)
|
|
ast = ast last
|
|
continue, // TCO
|
|
"if",
|
|
ast = if(EVAL(ast at(1), env), ast at(2), ast at(3))
|
|
continue, // TCO
|
|
"fn*",
|
|
return(MalFunc with(ast at(2), ast at(1), env, block(a, EVAL(ast at(2), Env with(env, ast at(1), a))))),
|
|
"let*",
|
|
letEnv := Env with(env)
|
|
varName := nil
|
|
ast at(1) foreach(i, e,
|
|
if(i % 2 == 0,
|
|
varName := e,
|
|
letEnv set(varName, EVAL(e, letEnv))
|
|
)
|
|
)
|
|
ast = ast at(2)
|
|
env = letEnv
|
|
continue, // TCO
|
|
"quote",
|
|
return(ast at(1)),
|
|
"quasiquote",
|
|
ast = quasiquote(ast at(1))
|
|
continue // TCO
|
|
)
|
|
)
|
|
|
|
// Apply
|
|
el := eval_ast(ast, env)
|
|
f := el at(0)
|
|
args := el rest
|
|
f type switch(
|
|
"Block",
|
|
return(f call(args)),
|
|
"MalFunc",
|
|
ast = f ast
|
|
env = Env with(f env, f params, args)
|
|
continue, // TCO
|
|
Exception raise("Unknown function type")
|
|
)
|
|
)
|
|
)
|
|
|
|
PRINT := method(exp, exp malPrint(true))
|
|
|
|
repl_env := Env with(nil)
|
|
|
|
RE := method(str, EVAL(READ(str), repl_env))
|
|
|
|
REP := method(str, PRINT(RE(str)))
|
|
|
|
MalCore NS foreach(k, v, repl_env set(MalSymbol with(k), v))
|
|
repl_env set(MalSymbol with("eval"), block(a, EVAL(a at(0), repl_env)))
|
|
repl_env set(MalSymbol with("*ARGV*"), MalList with(System args slice(2)))
|
|
|
|
// core.mal: defined using the language itself
|
|
RE("(def! not (fn* (a) (if a false true)))")
|
|
RE("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
|
|
|
|
if(System args size > 1,
|
|
REP("(load-file \"" .. (System args at(1)) .. "\")")
|
|
System exit(0)
|
|
)
|
|
|
|
loop(
|
|
line := MalReadline readLine("user> ")
|
|
if(line isNil, break)
|
|
if(line isEmpty, continue)
|
|
e := try(REP(line) println)
|
|
e catch(Exception,
|
|
("Error: " .. (e error)) println
|
|
)
|
|
)
|