refactor: break stdlib into several files

12 files changed, 749 insertions, 0 deletions

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("<lambda>", args[0].args, args[1:])
+    else:
+        func = UserFunction("<lambda>", [], 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)]))