From 776fe3193b515c028b5ac69326baed51d760d32f Mon Sep 17 00:00:00 2001 From: mryouse Date: Tue, 21 Jun 2022 01:49:29 +0000 Subject: refactor: break stdlib into several files --- neb/std/__init__.py | 11 +++ neb/std/boolean.py | 47 +++++++++++++ neb/std/core.py | 184 +++++++++++++++++++++++++++++++++++++++++++++++++++ neb/std/fs.py | 61 +++++++++++++++++ neb/std/functools.py | 46 +++++++++++++ neb/std/lists.py | 116 ++++++++++++++++++++++++++++++++ neb/std/math.py | 79 ++++++++++++++++++++++ neb/std/repl.py | 24 +++++++ neb/std/strings.py | 53 +++++++++++++++ neb/std/sys.py | 35 ++++++++++ neb/std/term.py | 33 +++++++++ neb/std/types.py | 60 +++++++++++++++++ 12 files changed, 749 insertions(+) create mode 100644 neb/std/__init__.py create mode 100644 neb/std/boolean.py create mode 100644 neb/std/core.py create mode 100644 neb/std/fs.py create mode 100644 neb/std/functools.py create mode 100644 neb/std/lists.py create mode 100644 neb/std/math.py create mode 100644 neb/std/repl.py create mode 100644 neb/std/strings.py create mode 100644 neb/std/sys.py create mode 100644 neb/std/term.py create mode 100644 neb/std/types.py (limited to 'neb/std') diff --git a/neb/std/__init__.py b/neb/std/__init__.py new file mode 100644 index 0000000..b6a4151 --- /dev/null +++ b/neb/std/__init__.py @@ -0,0 +1,11 @@ +from .boolean import BOOLEAN +from .core import CORE +from .functools import FUNCTOOLS +from .fs import FS +from .lists import LISTS +from .math import MATH +from .repl import REPL +from .strings import STRINGS +from .sys import SYS +from .term import TERM +from .types import TYPES diff --git a/neb/std/boolean.py b/neb/std/boolean.py new file mode 100644 index 0000000..b851d7d --- /dev/null +++ b/neb/std/boolean.py @@ -0,0 +1,47 @@ +from .. import TypeEnum, Environment, Arg, Builtin, evaluate +from ..structs import * + +BOOLEAN = Environment() + +def interpretOr(symbol, args, env, ns): + # or returns true for the first expression that returns true + for arg in args: + ev = evaluate(arg, env, ns) + if not isinstance(ev, Bool): + raise InterpretPanic(symbol, "requires :bool arguments") + if ev.value == True: + return ev + return Bool(False) + +or_arg = Arg("arg", TypeEnum.BOOL, lazy=True) +BOOLEAN.register("or", Builtin(interpretOr, [or_arg, or_arg], or_arg)) + +def interpretAnd(symbol, args, env, ns): + # and returns false for the first expression that returns false + for arg in args: + ev = evaluate(arg, env, ns) + if not isinstance(ev, Bool): + raise InterpretPanic(symbol, "requires :bool arguments") + if ev.value == False: + return ev + return Bool(True) + +BOOLEAN.register("and", Builtin(interpretAnd, [or_arg, or_arg], or_arg)) + +def interpretEq(symbol, args, env, ns): + # NOTE this currently only works for literals + # compare types because 0 != #false in neb + if type(args[0]) == type(args[1]) and args[0].value == args[1].value: + return Bool(True) + else: + return Bool(False) + +eq_arg = Arg("value", TypeEnum.LITERAL) +BOOLEAN.register("eq?", Builtin(interpretEq, [eq_arg, eq_arg])) + + +def interpretNot(symbol, args, env, ns): + return Bool(not args[0].value) + +not_arg = Arg("not", TypeEnum.BOOL) +BOOLEAN.register("not", Builtin(interpretNot, [not_arg])) diff --git a/neb/std/core.py b/neb/std/core.py new file mode 100644 index 0000000..d481daa --- /dev/null +++ b/neb/std/core.py @@ -0,0 +1,184 @@ +from .. import TypeEnum, Environment, Arg, Builtin, UserFunction, evaluate, interpret, parse, lex +from ..structs import * +from pathlib import Path + +CORE = Environment() + +def interpretIf(symbol, args, env, ns): + if args[0].value: + return evaluate(args[1], env, ns) + elif len(args) == 3: + return evaluate(args[2], env, ns) + return List([]) + +cond = Arg("cond", TypeEnum.BOOL) +t_branch = Arg("t-branch", TypeEnum.ANY, lazy=True) +f_branch = Arg("f-branch", TypeEnum.ANY, optional=True, lazy=True) +CORE.register("if", Builtin(interpretIf, [cond, t_branch, f_branch])) + +def interpretDef(symbol, args, env, ns): + + if not isinstance(args[0], Symbol): + raise InterpretPanic(symbol, "requires a :string name", args[0]) + name = args[0].name # NOTE: we are not evaluating the name!! + if not isinstance(name, str): + raise InterpretPanic(symbol, "requires a :string name") + + env.register(name, args[1]) # TODO since this isn't lazily evaluated, side effects are allowed (bad!) + + return List([]) + +def_name_arg = Arg("name", TypeEnum.ANY, lazy=True) +def_val_arg = Arg("value", TypeEnum.ANY) +CORE.register("def", Builtin(interpretDef, [def_name_arg, def_val_arg])) + +def interpretRedef(symbol, args, env, ns): + if not isinstance(args[0], Symbol): + raise InterpretPanic(symbol, "requires a :string name", args[0]) + name = args[0].name # NOTE: we are not evaluating the name!! + if not env.contains(name): + raise InterpretPanic(symbol, "not previously defined", args[0]) + + env.reregister(name, args[1]) + return List([]) + +CORE.register("redef", Builtin(interpretRedef, [def_name_arg, def_val_arg])) + +def interpretLambda(symbol, args, env, ns): + if len(args[0].args) != 0: + func = UserFunction("", args[0].args, args[1:]) + else: + func = UserFunction("", [], args[1:]) + return func + +lambda_args_arg = Arg("args", TypeEnum.ANY, lazy=True) +lambda_body_arg = Arg("body", TypeEnum.ANY, lazy=True) +CORE.register("lambda", Builtin(interpretLambda, [lambda_args_arg, lambda_body_arg], lambda_body_arg)) + +def interpretForCount(symbol, args, env, ns): + new_env = Environment(env) + ret = None + for idx in range(0, args[0].value): + new_env.register("idx", Int(idx + 1)) + for arg in args[1:]: + ret = evaluate(arg, new_env, ns) + if ret is None: + return List([]) + return ret + +for_count_arg = Arg("count", TypeEnum.INT) +for_body_arg = Arg("body", TypeEnum.ANY, lazy=True) +CORE.register("for-count", Builtin(interpretForCount, [for_count_arg, for_body_arg], for_body_arg)) + +def interpretForEach(symbol, args, env, ns): + new_env = Environment(env) + ret = None + for item in args[0].args: + new_env.register("_item_", evaluate(item, env, ns)) + for arg in args[1:]: + ret = evaluate(arg, new_env, ns) + if ret is None: + return List([]) + return ret + +for_each_arg = Arg("list", TypeEnum.LIST) +CORE.register("for-each", Builtin(interpretForEach, [for_each_arg, for_body_arg], for_body_arg)) + +def interpretBranch(symbol, args, env, ns): + for arg in args: + if len(arg.args) != 2: + raise InterpretPanic(symbol, "each branch requires two expressions") + cond = evaluate(arg.args[0], env, ns) # this is the condition + if not isinstance(cond, Bool): + raise InterpretPanic(symbol, "branch condition must be :bool", cond) + if cond.value: + return evaluate(arg.args[1], env, ns) + return List([]) + +CORE.register("branch", Builtin(interpretBranch, [for_body_arg], for_body_arg)) + +def interpretFunc(symbol, args, env, ns): + if not isinstance(args[0], Symbol): + raise InterpretPanic(symbol, "requires a :string name") + name = args[0].name # NOTE: we are not evaluating the name!! + + if ns is not None: + name = f"{ns}/{name}" + + # compose a lambda + func = interpretLambda(None, args[1:], env, ns) + + # add the name to the function + func.name = name + + env.register(name, func) + return List([]) + +CORE.register("func", Builtin(interpretFunc, [def_name_arg, lambda_args_arg, lambda_body_arg], lambda_body_arg)) + +def interpretBlock(symbol, args, env, ns): + ret = List([]) + for arg in args: + ret = evaluate(arg, env, ns) + return ret + +block_arg = Arg("expr", TypeEnum.ANY, lazy=True) +CORE.register("block", Builtin(interpretBlock, [block_arg], block_arg)) + +def interpretWhile(symbol, args, env, ns): + cond = args[0] + ret = List([]) + while True: + ev = evaluate(cond, env, ns) + if not isinstance(ev, Bool): + raise InterpretPanic(symbol, "expects a :bool condition", ev) + if not ev.value: + break + for arg in args[1:]: + ret = evaluate(arg, env, ns) + return ret + +CORE.register("while", Builtin(interpretWhile, [Arg("cond", TypeEnum.BOOL, lazy=True)], Arg("expr", TypeEnum.ANY, lazy=True))) + +def interpretUse(symbol, args, env, ns): + target_file_name = args[0].value + target_file = Path(target_file_name).resolve() + if not target_file.exists(): + raise InterpretPanic(symbol, "no such file", target_file) + with open(target_file, "r") as fil: + data = fil.read() + interpret(parse(lex(data)), env, ns) + return List([]) + +CORE.register("use", Builtin(interpretUse, [Arg("filename", TypeEnum.STRING)])) + +def interpretAssert(symbol, args, env, ns): + if args[0].value != True: + raise InterpretPanic(symbol, "assertion failed") + return List([]) + +CORE.register("assert", Builtin(interpretAssert, [Arg("cond", TypeEnum.BOOL)])) + +def interpretUseAs(symbol, args, env, ns): + target_file_name = args[0].value + target_file = Path(target_file_name).resolve() + if not target_file.exists(): + raise InterpretPanic(symbol, "no such file", target_file) + with open(target_file, "r") as fil: + data = fil.read() + interpret(parse(lex(data)), ns=args[1].name) + return List([]) + +CORE.register("use-as", Builtin(interpretUseAs, [Arg("filename", TypeEnum.STRING), Arg("namespace", TypeEnum.ANY, lazy=True)])) + +def interpretQuote(symbol, args, env, ns): + return args[0] + +quote_arg = Arg("arg", TypeEnum.ANY, lazy=True) +CORE.register("quote", Builtin(interpretQuote, [quote_arg])) + +def interpretEval(symbol, args, env, ns): + return evaluate(args[0], env, ns) # TODO why do i have to explicitly evaluate here? + +eval_arg = Arg("arg", TypeEnum.ANY) +CORE.register("eval", Builtin(interpretEval, [eval_arg])) diff --git a/neb/std/fs.py b/neb/std/fs.py new file mode 100644 index 0000000..2265719 --- /dev/null +++ b/neb/std/fs.py @@ -0,0 +1,61 @@ +from .. import TypeEnum, Environment, Arg, Builtin, evaluate +from ..structs import * +from pathlib import Path +from glob import glob + +FS = Environment() + +def interpretExists(symbol, args, env, ns): + return Bool(Path(args[0].value).resolve().exists()) + +FS.register("exists?", Builtin(interpretExists, [Arg("filename", TypeEnum.STRING)])) + +def interpretGlob(symbol, args, env, ns): + items = glob(args[0].value) + return List([String(item) for item in items]) + +FS.register("glob", Builtin(interpretGlob, [Arg("regex", TypeEnum.STRING)])) + +def interpretUnlink(symbol, args, env, ns): + target_path = Path(args[0].value).resolve() + if not target_path.exists(): + raise InterpretPanic(symbol, "target file does not exist", target_path) + target_path.unlink() + return List([]) + +FS.register("unlink", Builtin(interpretUnlink, [Arg("filename", TypeEnum.STRING)])) + +def interpretWithWrite(symbol, args, env, ns): + target_file = args[0] + new_env = Environment(env) + target_path = Path(target_file.value).resolve() + ret = Literal([]) + with open(str(target_path), "w") as fil: + new_env.register("_file_", List([fil])) # TODO wrong! + for arg in args[1:]: + ret = evaluate(arg, new_env, ns) + return ret + +FS.register("with-write", Builtin(interpretWithWrite, [Arg("filename", TypeEnum.STRING)], Arg("exprs", TypeEnum.ANY, lazy=True))) + +def interpretWrite(symbol, args, env, ns): + # write :string :filehandle + line = args[0] + handle = args[1] + handle.args[0].write(line.value) # TODO wrong! how do we evaluate a handle? + return Literal([]) + +FS.register("write", Builtin(interpretWrite, [Arg("string", TypeEnum.STRING), Arg("filename", TypeEnum.LIST)])) + +def interpretReadLines(symbol, args, env, ns): + target_file_name = args[0].value + target_file = Path(target_file_name).resolve() + if not target_file.exists(): + raise InterpretPanic(symbol, "no such file", target_file) + with open(target_file, "r") as fil: + data = fil.readlines() + out = List([String(d) for d in data]) # all lines are strings + return out + +FS.register("read-lines", Builtin(interpretReadLines, [Arg("filename", TypeEnum.STRING)])) + diff --git a/neb/std/functools.py b/neb/std/functools.py new file mode 100644 index 0000000..59f4a2a --- /dev/null +++ b/neb/std/functools.py @@ -0,0 +1,46 @@ +from .. import TypeEnum, Environment, Arg, Builtin, Function, evaluate +from ..structs import * + +FUNCTOOLS = Environment() + +def interpretFilter(symbol, args, env, ns): + func = args[0] + if not isinstance(func, Function): + raise InterpretPanic(symbol, "requires a :func as its first argument", func) + lst = args[1] + out = [] + for arg in lst.args: + ev = func.call(Expr([func, arg]), env, ns) + if not isinstance(ev, Bool): + raise InterpretPanic(symbol, "function must return :bool", ev) + if ev.value: + out.append(arg) + return List(out) + +FUNCTOOLS.register("filter", Builtin(interpretFilter, [Arg("func", TypeEnum.ANY), Arg("list", TypeEnum.LIST)])) + +def interpretMap(symbol, args, env, ns): + func = args[0] + if not isinstance(func, Function): + raise InterpretPanic(symbol, "requires a :func as its first argument", func) + lst = args[1] + if not isinstance(lst, List): + raise InterpretPanic(symbol, "requires a :list as its second argument", lst) + out = [] + for arg in lst.args: + ev = func.call(Expr([func, arg]), env, ns) + out.append(ev) + return List(out) + +FUNCTOOLS.register("map", Builtin(interpretMap, [Arg("func", TypeEnum.ANY), Arg("list", TypeEnum.LIST)])) + +def interpretApply(symbol, args, env, ns): + # TODO: to support lambdas, we can't assume the func is defined + func = args[0] + if not isinstance(func, Symbol): + raise InterpretPanic(symbol, "requires a symbol as its first argument", func) + new_lst = List([func] + args[1].args) + return evaluate(new_lst, env, ns) + +FUNCTOOLS.register("apply", Builtin(interpretApply, [Arg("func", TypeEnum.ANY, lazy=True), Arg("list", TypeEnum.LIST)])) + diff --git a/neb/std/lists.py b/neb/std/lists.py new file mode 100644 index 0000000..d5c18c2 --- /dev/null +++ b/neb/std/lists.py @@ -0,0 +1,116 @@ +from .. import TypeEnum, Environment, Arg, Builtin, evaluate +from ..structs import * +import random + +LISTS = Environment() + +def interpretListLength(symbol, args, env, ns): + return Int(len(args[0].args)) + +LISTS.register("list-length", Builtin(interpretListLength, [Arg("arg", TypeEnum.LIST)])) + +def interpretFirst(symbol, args, env, ns): + if len(args[0].args) == 0: + raise InterpretPanic(symbol, "list is empty") + return evaluate(args[0].args[0], env, ns) + +LISTS.register("first", Builtin(interpretFirst, [Arg("arg", TypeEnum.LIST, )])) + +def interpretRest(symbol, args, env, ns): + # TODO do we know it's not evaluated? + return List(args[0].args[1:]) # we don't evaluate the remainder of the list + +LISTS.register("rest", Builtin(interpretRest, [Arg("arg", TypeEnum.LIST)])) + +def interpretListReverse(symbol, args, env, ns): + new_args = args[0].args[:] # make a copy of the args + new_args.reverse() + return List(new_args) + +LISTS.register("list-reverse", Builtin(interpretListReverse, [Arg("list", TypeEnum.LIST)])) + +def interpretEmpty(symbol, args, env, ns): + return Bool(len(args[0].args) == 0) + +LISTS.register("empty?", Builtin(interpretEmpty, [Arg("list", TypeEnum.LIST)])) + +def interpretShuf(symbol, args, env, ns): + items = args[0].args[:] + random.shuffle(items) + return List(items) + +LISTS.register("shuf", Builtin(interpretShuf, [Arg("list", TypeEnum.LIST)])) + +def interpretIn(symbol, args, env, ns): + target = args[0] + lst = args[1] + for arg in lst.args: + if type(arg) == type(target) and arg.value == target.value: + return Bool(True) + return Bool(False) + +in_target_arg = Arg("target", TypeEnum.LITERAL) +in_list_arg = Arg("list", TypeEnum.LIST) +LISTS.register("in?", Builtin(interpretIn, [in_target_arg, in_list_arg])) + +def interpretLast(symbol, args, env, ns): + if len(args[0].args) == 0: + raise InterpretPanic("List is empty") + return evaluate(args[0].args[-1], env, ns) + +LISTS.register("last", Builtin(interpretLast, [Arg("list", TypeEnum.LIST)])) + +def interpretSlice(symbol, args, env, ns): + lst = args[0] + idx = args[1] + if len(args) == 2: + return List(lst.args[idx.value - 1:]) + length = args[2] + diff = idx.value - 1 + length.value + return List(lst.args[idx.value - 1:diff]) + +slice_list_arg = Arg("list", TypeEnum.LIST) +slice_idx_arg = Arg("idx", TypeEnum.INT) +slice_length_arg = Arg("length", TypeEnum.INT, optional=True) +LISTS.register("slice", Builtin(interpretSlice, [slice_list_arg, slice_idx_arg, slice_length_arg])) + +def interpretAppend(symbol, args, env, ns): + lst = args[0] + val = args[1] + items = lst.args[:] + return List(items + [val]) + +LISTS.register("append", Builtin(interpretAppend, [Arg("list", TypeEnum.LIST), Arg("item", TypeEnum.ANY)])) + +# TODO: this is actually for records/structs/whatever they're called +def interpretRemove(symbol, args, env, ns): + lst = args[0] + key = args[1] + out = [] + for arg in lst.args: + if arg.args[0].value != key.value: + out.append(arg) + return List(out) + +LISTS.register("remove", Builtin(interpretRemove, [Arg("list", TypeEnum.LIST), Arg("key", TypeEnum.ANY)])) + +def interpretZip(symbol, args, env, ns): + z1 = args[0] + z2 = args[1] + if len(z1.args) != len(z2.args): + raise InterpretPanic(symbol, "requires two :lists of the same size") + out = [] + for idx in range(len(z1.args)): + f = z1.args[idx] + s = z2.args[idx] + out.append(List([f, s])) + return List(out) + +zip_arg = Arg("list", TypeEnum.LIST) +LISTS.register("zip", Builtin(interpretZip, [zip_arg, zip_arg])) + +def interpretList(symbol, args, env, ns): + return List(args) + +LISTS.register("list", Builtin(interpretList, [], Arg("item", TypeEnum.ANY))) + diff --git a/neb/std/math.py b/neb/std/math.py new file mode 100644 index 0000000..85d4f55 --- /dev/null +++ b/neb/std/math.py @@ -0,0 +1,79 @@ +from .. import TypeEnum, Environment, Arg, Builtin, evaluate +from ..structs import * +import math + +MATH = Environment() + +def interpretLessThanEqual(symbol, args, env, ns): + return Bool(args[0].value <= args[1].value) + +compare_arg = Arg("num", TypeEnum.NUMBER) +MATH.register("<=", Builtin(interpretLessThanEqual, [compare_arg, compare_arg])) + +def interpretGreaterThan(symbol, args, env, ns): + return Bool(args[0].value > args[1].value) + +compare_arg = Arg("num", TypeEnum.NUMBER) +MATH.register(">", Builtin(interpretGreaterThan, [compare_arg, compare_arg])) + +def interpretGreaterThanEqual(symbol, args, env, ns): + return Bool(args[0].value >= args[1].value) + +MATH.register(">=", Builtin(interpretGreaterThanEqual, [compare_arg, compare_arg])) + +def interpretLessThan(symbol, args, env, ns): + return Bool(args[0].value < args[1].value) + +MATH.register("<", Builtin(interpretLessThan, [compare_arg, compare_arg])) + +def interpretAddition(symbol, args, env, ns): + res = 0 + for arg in args: + res += arg.value + if isinstance(res, float): + return Float(res) + else: + return Int(res) + +term_arg = Arg("term", TypeEnum.NUMBER) +MATH.register("+", Builtin(interpretAddition, [term_arg], term_arg)) + +def interpretSubtraction(symbol, args, env, ns): + if len(args) == 1: + res = -args[0].value + else: + res = args[0].value + for arg in args[1:]: + res -= arg.value + if isinstance(res, float): + return Float(res) + else: + return Int(res) + +MATH.register("-", Builtin(interpretSubtraction, [term_arg], term_arg)) + +def interpretMultiplication(symbol, args, env, ns): + res = args[0].value + for arg in args[1:]: + res = res * arg.value + if isinstance(res, float): + return Float(res) + else: + return Int(res) + +factor_arg = Arg("factor", TypeEnum.NUMBER) +MATH.register("*", Builtin(interpretMultiplication, [factor_arg, factor_arg], factor_arg)) + +def interpretDivision(symbol, args, env, ns): + ret = args[0].value / args[1].value + if int(ret) == ret: + return Int(int(ret)) + else: + return Float(ret) + +MATH.register("/", Builtin(interpretDivision, [factor_arg, factor_arg])) + +def interpretFloor(symbol, args, env, ns): + return Int(math.floor(args[0].value)) + +MATH.register("floor", Builtin(interpretFloor, [Arg("floor", TypeEnum.NUMBER)])) diff --git a/neb/std/repl.py b/neb/std/repl.py new file mode 100644 index 0000000..48a7811 --- /dev/null +++ b/neb/std/repl.py @@ -0,0 +1,24 @@ +from .. import TypeEnum, Environment, Arg, Builtin, UserFunction, evaluate +from ..structs import * + +REPL = Environment() + +def interpretHowTo(symbol, args, env, ns): + if not isinstance(args[0], Function): + raise InterpretPanic(symbol, "expects a :func", args[0]) + print(args[0].describe()) + return List([]) + +REPL.register("howto", Builtin(interpretHowTo, [Arg("symbol", TypeEnum.ANY)])) + +def interpretSymbols(symbol, args, env, ns): + keys = [Symbol(k, -1) for k,v in env.environment.items()] + return List(keys) + +REPL.register("symbols", Builtin(interpretSymbols, [])) + +def interpretUserSymbols(symbol, args, env, ns): + keys = [Symbol(k, -1) for k,v in env.environment.items() if isinstance(v, UserFunction) or isinstance(v, Literal)] + return List(keys) + +REPL.register("user-symbols", Builtin(interpretUserSymbols, [])) diff --git a/neb/std/strings.py b/neb/std/strings.py new file mode 100644 index 0000000..0d5ebdb --- /dev/null +++ b/neb/std/strings.py @@ -0,0 +1,53 @@ +from .. import TypeEnum, Environment, Arg, Builtin, evaluate +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) +STRINGS.register("concat", Builtin(interpretConcat, [string_arg, string_arg], string_arg)) + +def interpretStrip(symbol, args, env, ns): + return String(args[0].value.strip()) + +STRINGS.register("strip", Builtin(interpretStrip, [Arg("filename", TypeEnum.STRING)])) +def interpretStrip(symbol, args, env, ns): + return String(args[0].value.strip()) + +STRINGS.register("strip", Builtin(interpretStrip, [Arg("filename", TypeEnum.STRING)])) + +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]) + +STRINGS.register("split", Builtin(interpretSplit, [Arg("target", TypeEnum.STRING)], Arg("splitter", TypeEnum.STRING, optional=True))) + +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) +STRINGS.register("join", Builtin(interpretJoin, [join_list_arg, join_string_arg])) + +def interpretFirstChar(symbol, args, env, ns): + if len(args[0].value) == 0: + raise InterpretPanic(symbol, ":string is empty", ev) + return String(args[0].value[0]) + +STRINGS.register("first-char", Builtin(interpretFirstChar, [Arg("string", TypeEnum.STRING)])) + +def interpretRestChar(symbol, args, env, ns): + return String(args[0].value[1:]) + +STRINGS.register("rest-char", Builtin(interpretRestChar, [Arg("string", TypeEnum.STRING)])) diff --git a/neb/std/sys.py b/neb/std/sys.py new file mode 100644 index 0000000..252a0b0 --- /dev/null +++ b/neb/std/sys.py @@ -0,0 +1,35 @@ +from .. import TypeEnum, Environment, Arg, Builtin, evaluate +from ..structs import * +import shlex +import subprocess +import sys + +SYS = Environment() + +def interpretArgv(symbol, args, env, ns): + out = [] + for arg in sys.argv[1:]: + out.append(String(arg)) + return List(out) + +SYS.register("argv", Builtin(interpretArgv, [])) + +def interpretShell(symbol, args, env, ns): + ret = subprocess.run(shlex.split(args[0].value), capture_output=True) + return List([String(r) for r in ret.stdout.decode("utf-8").split("\n")]) + +SYS.register("$", Builtin(interpretShell, [Arg("command", TypeEnum.STRING)])) + +def interpretExit(symbol, args, env, ns): + status = 0 if len(args) == 0 else args[0].value + sys.exit(status) + return List([]) + +exit_arg = Arg("status", TypeEnum.INT, optional=True) +SYS.register("exit", Builtin(interpretExit, [exit_arg])) + +def interpretPrint(symbol, args, env, ns): + print(args[0].value) + return List([]) # print returns nothing + +SYS.register("print", Builtin(interpretPrint, [Arg("arg", TypeEnum.STRING)])) diff --git a/neb/std/term.py b/neb/std/term.py new file mode 100644 index 0000000..e706005 --- /dev/null +++ b/neb/std/term.py @@ -0,0 +1,33 @@ +from .. import TypeEnum, Environment, Arg, Builtin, evaluate +from ..structs import * +import subprocess +import sys + +TERM = Environment() + +def interpretClear(symbol, args, env, ns): + subprocess.run(["clear"]) + return List([]) + +TERM.register("clear", Builtin(interpretClear, [])) + +def interpretReadLine(symbol, args, env, ns): + ret = input(args[0].value) + return String(ret) + +TERM.register("read-line", Builtin(interpretReadLine, [Arg("prompt", TypeEnum.STRING)])) + +def interpretReadChar(symbol, args, env, ns): + import termios, tty + fd = sys.stdin.fileno() + old = termios.tcgetattr(fd) + try: + tty.setraw(fd) + ch = sys.stdin.buffer.read1(4) # some keys are >1 bytes + except Exception: + raise + finally: + termios.tcsetattr(fd, termios.TCSADRAIN, old) + return String(ch.decode("utf-8")) + +TERM.register("read-char", Builtin(interpretReadChar, [])) diff --git a/neb/std/types.py b/neb/std/types.py new file mode 100644 index 0000000..3cf55ac --- /dev/null +++ b/neb/std/types.py @@ -0,0 +1,60 @@ +from .. import TypeEnum, Environment, Arg, Builtin, evaluate +from ..structs import * + +TYPES = Environment() + +def interpretIsBool(symbol, args, env, ns): + return Bool(isinstance(args[0], Bool)) + +TYPES.register("bool?", Builtin(interpretIsBool, [Arg("arg", TypeEnum.ANY)])) + +def interpretIsFloat(symbol, args, env, ns): + return Bool(isinstance(args[0], Float)) + +TYPES.register("float?", Builtin(interpretIsFloat, [Arg("arg", TypeEnum.ANY)])) + +def interpretIsNumber(symbol, args, env, ns): + ret = isinstance(args[0], Int) or isinstance(args[0], Float) + return Bool(ret) + +TYPES.register("number?", Builtin(interpretIsNumber, [Arg("arg", TypeEnum.ANY)])) + +def interpretIsInt(symbol, args, env, ns): + return Bool(isinstance(args[0], Int)) + +TYPES.register("int?", Builtin(interpretIsInt, [Arg("arg", TypeEnum.ANY)])) + +def interpretIsList(symbol, args, env, ns): + return Bool(isinstance(args[0], List)) + +TYPES.register("list?", Builtin(interpretIsList, [Arg("arg", TypeEnum.ANY)])) + +def interpretIsString(symbol, args, env, ns): + return Bool(isinstance(args[0], String)) + +TYPES.register("string?", Builtin(interpretIsString, [Arg("arg", TypeEnum.ANY)])) + +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(interpretStringToInt, [Arg("arg", TypeEnum.STRING)])) + +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(interpretToString, [Arg("arg", TypeEnum.ANY)])) + +def interpretTypeOf(symbol, args, env, ns): + return Type(f"{args[0].type_}") + +TYPES.register("typeof", Builtin(interpretTypeOf, [Arg("candidate", TypeEnum.ANY)])) -- cgit v1.2.3