auto-editor 23.35.1__py3-none-any.whl → 23.40.1__py3-none-any.whl

auto_editor/lang/palet.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 import cmath
 import math
-import random
+from dataclasses import dataclass
 from difflib import get_close_matches
 from fractions import Fraction
 from functools import reduce
@@ -17,6 +17,7 @@ from time import sleep
 from typing import TYPE_CHECKING
 
 import numpy as np
+from numpy import logical_and, logical_not, logical_or, logical_xor
 
 from auto_editor.analyze import edit_method, mut_remove_large, mut_remove_small
 from auto_editor.lib.contracts import *
@@ -26,7 +27,7 @@ from auto_editor.utils.func import boolop, mut_margin
 
 if TYPE_CHECKING:
     from collections.abc import Callable
-    from typing import Any, NoReturn
+    from typing import Any, Literal, NoReturn
 
     from numpy.typing import NDArray
 
@@ -45,11 +46,10 @@ class ClosingError(MyError):
 #                                                                             #
 ###############################################################################
 
-SEC_UNITS = ("s", "sec", "secs", "second", "seconds")
-VAL, QUOTE, SEC, DB, PER, DOT = "VAL", "QUOTE", "SEC", "DB", "PER", "DOT"
 LPAREN, RPAREN, LBRAC, RBRAC, LCUR, RCUR, EOF = "(", ")", "[", "]", "{", "}", "EOF"
-VLIT = "VLIT"
-METHODS = ("audio:", "motion:", "pixeldiff:", "subtitle:", "none:", "all/e:")
+VAL, QUOTE, SEC, DB, DOT, VLIT = "VAL", "QUOTE", "SEC", "DB", "DOT", "VLIT"
+SEC_UNITS = ("s", "sec", "secs", "second", "seconds")
+METHODS = ("audio:", "motion:", "pixeldiff:", "subtitle:")
 brac_pairs = {LPAREN: RPAREN, LBRAC: RBRAC, LCUR: RCUR}
 
 str_escape = {
@@ -65,17 +65,10 @@ str_escape = {
 }
 
 
+@dataclass(slots=True)
 class Token:
-    __slots__ = ("type", "value")
-
-    def __init__(self, type: str, value: Any):
-        self.type = type
-        self.value = value
-
-    def __str__(self) -> str:
-        return f"(Token {print_str(self.type)} {print_str(self.value)})"
-
-    __repr__ = __str__
+    type: str
+    value: Any
 
 
 class Lexer:
@@ -171,19 +164,16 @@ class Lexer:
                 token = SEC
             elif unit == "dB":
                 token = DB
-            elif unit == "%":
-                token = PER
-            elif unit != "i":
+            elif unit != "i" and unit != "%":
                 return Token(VAL, Sym(result + unit))
 
         try:
             if unit == "i":
                 return Token(VAL, complex(result + "j"))
+            elif unit == "%":
+                return Token(VAL, float(result) / 100)
             elif "/" in result:
-                val = Fraction(result)
-                if val.denominator == 1:
-                    return Token(token, val.numerator)
-                return Token(token, val)
+                return Token(token, Fraction(result))
             elif "." in result:
                 return Token(token, float(result))
             else:
@@ -201,6 +191,16 @@ class Lexer:
             self.advance()
             return Token(VAL, Char(char))
 
+        if self.char == ":":
+            self.advance()
+            buf = StringIO()
+            while self.char_is_norm():
+                assert self.char is not None
+                buf.write(self.char)
+                self.advance()
+
+            return Token(VAL, Keyword(buf.getvalue()))
+
         if self.char is not None and self.char in "([{":
             brac_type = self.char
             self.advance()
@@ -368,14 +368,12 @@ class Lexer:
 ###############################################################################
 
 
+@dataclass(slots=True)
 class Method:
-    __slots__ = "val"
-
-    def __init__(self, val: str):
-        self.val = val
+    val: str
 
     def __str__(self) -> str:
-        return f'(Method "{self.val}")'
+        return f"#<method:{self.val}>"
 
     __repr__ = __str__
 
@@ -405,6 +403,7 @@ class Parser:
             self.eat()
             return [list, lit_arr]
 
+        # Handle unhygienic macros in next four cases
         if token.type == SEC:
             self.eat()
             return [Sym("round"), [Sym("*"), token.value, Sym("timebase")]]
@@ -413,10 +412,6 @@ class Parser:
             self.eat()
             return [Sym("pow"), 10, [Sym("/"), token.value, 20]]
 
-        if token.type == PER:
-            self.eat()
-            return [Sym("/"), token.value, 100.0]
-
         if token.type == DOT:
             self.eat()
             if type(token.value[1].value) is not Sym:
@@ -463,43 +458,15 @@ class Parser:
 ###############################################################################
 
 
-def check_args(
-    o: str,
-    values: list | tuple,
-    arity: tuple[int, int | None],
-    cont: list[Contract] | None,
-) -> None:
-    lower, upper = arity
-    amount = len(values)
-    if upper is not None and lower > upper:
-        raise ValueError("lower must be less than upper")
-    if lower == upper and len(values) != lower:
-        raise MyError(f"{o}: Arity mismatch. Expected {lower}, got {amount}")
-
-    if upper is None and amount < lower:
-        raise MyError(f"{o}: Arity mismatch. Expected at least {lower}, got {amount}")
-    if upper is not None and (amount > upper or amount < lower):
-        raise MyError(
-            f"{o}: Arity mismatch. Expected between {lower} and {upper}, got {amount}"
-        )
-
-    if cont is None:
-        return
-
-    for i, val in enumerate(values):
-        check = cont[-1] if i >= len(cont) else cont[i]
-        if not check_contract(check, val):
-            raise MyError(f"{o} expected a {check.name}, got {print_str(val)}")
-
-
 is_cont = Contract("contract?", is_contract)
 is_iterable = Contract(
     "iterable?",
-    lambda v: type(v) in (str, range) or isinstance(v, (list, dict, np.ndarray)),
+    lambda v: type(v) in (str, range, Quoted)
+    or isinstance(v, (list, dict, np.ndarray)),
 )
 is_sequence = Contract(
     "sequence?",
-    lambda v: type(v) in (str, range) or isinstance(v, (list, np.ndarray)),
+    lambda v: type(v) in (str, range, Quoted) or isinstance(v, (list, np.ndarray)),
 )
 is_boolarr = Contract(
     "bool-array?",
@@ -509,6 +476,32 @@ bool_or_barr = Contract(
     "(or/c bool? bool-array?)",
     lambda v: type(v) is bool or is_boolarr(v),
 )
+is_keyw = Contract("keyword?", lambda v: type(v) is QuotedKeyword)
+
+
+@dataclass(slots=True)
+class OutputPort:
+    name: str
+    port: Any
+    write: Any
+    closed: bool
+
+    def close(self) -> None:
+        if not self.closed:
+            self.port.close()
+
+    def __str__(self) -> str:
+        return f"#<output-port:{self.name}>"
+
+    __repr__ = __str__
+
+
+def initOutPort(name: str) -> OutputPort | Literal[False]:
+    try:
+        port = open(name, "w", encoding="utf-8")
+    except Exception:
+        return False
+    return OutputPort(name, port, port.write, False)
 
 
 def raise_(msg: str) -> None:
@@ -544,13 +537,8 @@ def num_div(z: Number, *w: Number) -> Number:
         if num == 0:
             raise MyError("/: division by zero")
 
-        if type(num) is int:
-            num = Fraction(num)
-
         z /= num
 
-    if type(z) is Fraction and z.denominator == 1:
-        return z.numerator
     return z
 
 
@@ -572,9 +560,9 @@ def _sqrt(v: Number) -> Number:
 
 def _xor(*vals: Any) -> bool | BoolList:
     if is_boolarr(vals[0]):
-        check_args("xor", vals, (2, None), [is_boolarr])
-        return reduce(lambda a, b: boolop(a, b, np.logical_xor), vals)
-    check_args("xor", vals, (2, None), [is_bool])
+        check_args("xor", vals, (2, None), (is_boolarr,))
+        return reduce(lambda a, b: boolop(a, b, logical_xor), vals)
+    check_args("xor", vals, (2, None), (is_bool,))
     return reduce(lambda a, b: a ^ b, vals)
 
 
@@ -600,6 +588,13 @@ def number_to_string(val: Number) -> str:
     return f"{val}"
 
 
+def palet_join(v: Any, s: str) -> str:
+    try:
+        return s.join(v)
+    except Exception:
+        raise MyError("join: expected string?")
+
+
 dtype_map = {
     Sym("bool"): np.bool_,
     Sym("int8"): np.int8,
@@ -662,11 +657,11 @@ def maxcut(oarr: BoolList, _min: int) -> BoolList:
 
 def margin(a: int, b: Any, c: Any = None) -> BoolList:
     if c is None:
-        check_args("margin", [a, b], (2, 2), [is_int, is_boolarr])
+        check_args("margin", [a, b], (2, 2), (is_int, is_boolarr))
         oarr = b
         start, end = a, a
     else:
-        check_args("margin", [a, b, c], (3, 3), [is_int, is_int, is_boolarr])
+        check_args("margin", [a, b, c], (3, 3), (is_int, is_int, is_boolarr))
         oarr = c
         start, end = a, b
 
@@ -687,28 +682,14 @@ def vector_extend(vec: list, *more_vecs: list) -> None:
         vec.extend(more)
 
 
-def randrange(*args: int) -> int:
-    try:
-        return random.randrange(*args)
-    except ValueError:
-        raise MyError("randrange: got empty range")
-
-
-def palet_map(proc: Proc, seq: str | list | range | NDArray) -> Any:
+def palet_map(proc: Proc, seq: Any) -> Any:
     if type(seq) is str:
-        return str(map(proc.proc, seq))
+        return str(map(proc, seq))
+    if type(seq) is Quoted:
+        return Quoted(list(map(proc, seq.val)))
     if isinstance(seq, (list, range)):
-        return list(map(proc.proc, seq))
-
-    if isinstance(seq, np.ndarray):
-        if proc.arity[0] != 0:
-            raise MyError("map: procedure must take at least one arg")
-        check_args(proc.name, [0], (1, 1), None)
-        return proc.proc(seq)
-
-
-def apply(proc: Proc, seq: str | list | range) -> Any:
-    return reduce(proc.proc, seq)
+        return list(map(proc, seq))
+    return proc(seq)
 
 
 def ref(seq: Any, ref: int) -> Any:
@@ -791,41 +772,99 @@ def palet_system(cmd: str) -> bool:
 class UserProc(Proc):
     """A user-defined procedure."""
 
-    __slots__ = ("env", "parms", "body", "name", "arity", "contracts")
+    __slots__ = ("env", "name", "parms", "body", "contracts", "arity")
 
     def __init__(
         self,
         env: Env,
         name: str,
-        parms: list,
+        parms: list[str],
+        contracts: tuple[Any, ...],
         body: list,
-        contracts: list[Any] | None = None,
-        eat_last: bool = False,
     ):
         self.env = env
-        self.parms = [f"{p}" for p in parms]
-        self.body = body
         self.name = name
+        self.parms = parms
+        self.body = body
+        self.contracts = contracts
 
-        if eat_last:
+        if parms and parms[-1] == "...":
+            parms.pop()
             self.arity: tuple[int, int | None] = len(parms) - 1, None
         else:
             self.arity = len(parms), len(parms)
 
-        self.contracts = contracts
-
     def __call__(self, *args: Any) -> Any:
+        check_args(self.name, args, self.arity, self.contracts)
+
         if self.arity[1] is None:
-            largs = list(args)
-            args = tuple([largs[len(self.parms) - 1 :]])
+            args = tuple(
+                list(args[: len(self.parms) - 1]) + [list(args[len(self.parms) - 1 :])]
+            )
 
         inner_env = Env(dict(zip(self.parms, args)), self.env)
 
         for item in self.body[0:-1]:
             my_eval(inner_env, item)
-        result = my_eval(inner_env, self.body[-1])
 
-        return result
+        return my_eval(inner_env, self.body[-1])
+
+
+@dataclass(slots=True)
+class KeywordProc:
+    env: Env
+    name: str
+    parms: list[str]
+    kw_parms: list[str]
+    body: list
+    arity: tuple[int, None]
+    contracts: list[Any] | None = None
+
+    def __call__(self, *args: Any) -> Any:
+        env = {}
+
+        for i, parm in enumerate(self.parms):
+            if type(args[i]) is Keyword:
+                raise MyError(f"Invalid keyword `{args[i]}`")
+            env[parm] = args[i]
+
+        remain_args = args[len(self.parms) :]
+
+        allow_pos = True
+        pos_index = 0
+        key = ""
+        for arg in remain_args:
+            if type(arg) is Keyword:
+                if key:
+                    raise MyError("Expected value for keyword but got another keyword")
+                key = arg.val
+                allow_pos = False
+            elif key:
+                env[key] = arg
+                key = ""
+            else:
+                if not allow_pos:
+                    raise MyError("Positional argument not allowed here")
+                if pos_index >= len(self.kw_parms):
+                    base = f"`{self.name}` has an arity mismatch. Expected"
+                    upper = len(self.parms) + len(self.kw_parms)
+                    raise MyError(f"{base} at most {upper}")
+
+                env[self.kw_parms[pos_index]] = arg
+                pos_index += 1
+
+        inner_env = Env(env, self.env)
+
+        for item in self.body[0:-1]:
+            my_eval(inner_env, item)
+
+        return my_eval(inner_env, self.body[-1])
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __repr__(self) -> str:
+        return f"#<kw-proc:{self.name}>"
 
 
 class Syntax:
@@ -868,62 +907,97 @@ def check_for_syntax(env: Env, node: list) -> tuple[Sym, Any]:
 
 
 def syn_lambda(env: Env, node: list) -> UserProc:
-    if not isinstance(node[1], list):
+    if len(node) < 3:
+        raise MyError(f"{node[0]}: too few terms")
+
+    if type(node[1]) is not list:
         raise MyError(f"{node[0]}: bad syntax")
 
-    return UserProc(env, "", node[1], node[2:])  # parms, body
+    parms: list[str] = []
+    for item in node[1]:
+        if type(item) is not Sym:
+            raise MyError(f"{node[0]}: must be an identifier")
+
+        parms.append(f"{item}")
+
+    return UserProc(env, "", parms, (), node[2:])
 
 
 def syn_define(env: Env, node: list) -> None:
     if len(node) < 3:
-        raise MyError(f"{node[0]}: too few args")
+        raise MyError(f"{node[0]}: too few terms")
+
+    if type(node[1]) is list:
+        term = node[1]
+        body = node[2:]
 
-    if isinstance(node[1], list):
-        if not node[1] or type(node[1][0]) is not Sym:
+        if not term or type(term[0]) is not Sym:
             raise MyError(f"{node[0]}: proc-binding must be an identifier")
 
-        n = node[1][0].val
+        n = term[0].val
+        parms: list[str] = []
+        kparms: list[str] = []
+        kw_only = False
+
+        for item in term[1:]:
+            if kw_only:
+                if type(item) is Sym:
+                    raise MyError(f"{node[0]}: {item} must be a keyword")
+                if type(item) is not Keyword:
+                    raise MyError(f"{node[0]}: must be a keyword")
+                kparms.append(item.val)
+            else:
+                if type(item) is Keyword:
+                    kw_only = True
+                    kparms.append(item.val)
+                elif type(item) is Sym:
+                    parms.append(item.val)
+                else:
+                    raise MyError(f"{node[0]}: must be an identifier")
 
-        eat_last = False
-        if node[1][1:] and node[1][-1] == Sym("..."):
-            eat_last = True
-            parameters = node[1][1:-1]
+        if kw_only:
+            env[n] = KeywordProc(env, n, parms, kparms, body, (len(parms), None))
         else:
-            parameters = node[1][1:]
-
-        body = node[2:]
-        env[n] = UserProc(env, n, parameters, body, eat_last=eat_last)
+            env[n] = UserProc(env, n, parms, (), body)
         return None
+
     elif type(node[1]) is not Sym:
         raise MyError(f"{node[0]}: must be an identifier")
 
-    n = node[1].val
-
     if len(node) > 3:
-        raise MyError(f"{node[0]}: bad syntax (multiple expressions after identifier)")
+        raise MyError(f"{node[0]}: multiple expressions after identifier")
+
+    n = node[1].val
 
     if (
-        isinstance(node[2], list)
+        type(node[2]) is list
         and node[2]
         and type(node[2][0]) is Sym
         and node[2][0].val in ("lambda", "λ")
     ):
-        parameters = node[2][1]
+        terms = node[2][1]
         body = node[2][2:]
-        env[n] = UserProc(env, n, parameters, body)
+
+        parms = []
+        for item in terms:
+            if type(item) is not Sym:
+                raise MyError(f"{node[0]}: must be an identifier")
+
+            parms.append(f"{item}")
+
+        env[n] = UserProc(env, n, parms, (), body)
+
     else:
         for item in node[2:-1]:
             my_eval(env, item)
         env[n] = my_eval(env, node[-1])
 
-    return None
-
 
 def syn_definec(env: Env, node: list) -> None:
     if len(node) < 3:
-        raise MyError(f"{node[0]}: bad syntax")
+        raise MyError(f"{node[0]}: too few terms")
 
-    if not isinstance(node[1], list):
+    if type(node[1]) is not list:
         raise MyError(f"{node[0]} only allows procedure declarations")
 
     if not node[1] or type(node[1][0]) is not Sym:
@@ -931,22 +1005,24 @@ def syn_definec(env: Env, node: list) -> None:
 
     n = node[1][0].val
 
-    contracts: list[Proc | Contract] = []
-    parameters: list[Sym] = []
+    contracts: list[Any] = []
+    parms: list[str] = []
     for item in node[1][1:]:
-        if len(item) != 2:
+        if item == Sym("->"):
+            break
+        if type(item) is not list or len(item) != 2:
             raise MyError(f"{node[0]}: bad var-binding syntax")
         if type(item[0]) is not Sym:
             raise MyError(f"{node[0]}: binding must be identifier")
 
-        parameters.append(item[0])
         con = my_eval(env, item[1])
         if not is_cont(con):
             raise MyError(f"{node[0]}: {print_str(con)} is not a valid contract")
 
+        parms.append(f"{item[0]}")
         contracts.append(con)
 
-    env[n] = UserProc(env, n, parameters, node[2:], contracts)
+    env[n] = UserProc(env, n, parms, tuple(contracts), node[2:])
     return None
 
 
@@ -1015,6 +1091,23 @@ def syn_decf(env: Env, node: list) -> None:
         env[name] -= 1
 
 
+def syn_strappend(env: Env, node: list) -> None:
+    guard_term(node, 3, 3)
+
+    if type(node[1]) is not Sym:
+        raise MyError(f"{node[0]}: Expected identifier, got {print_str(node[1])}")
+    name = node[1].val
+
+    if env[name] is None:
+        raise MyError(f"{node[0]}: `{name}` is not defined")
+    if not is_str(env[name]):
+        raise MyError(f"{node[0]}: `{name}` is not a string?")
+
+    if not is_str(num := my_eval(env, node[2])):
+        raise MyError(f"{node[0]}: Expected string? got: {print_str(num)}")
+    env[name] += num
+
+
 def syn_for(env: Env, node: list) -> None:
     var, my_iter = check_for_syntax(env, node)
 
@@ -1030,8 +1123,12 @@ def syn_for(env: Env, node: list) -> None:
                 my_eval(env, c)
 
 
-def syn_quote(env: Env, node: list) -> list:
+def syn_quote(env: Env, node: list) -> Any:
     guard_term(node, 2, 2)
+    if type(node[1]) is Keyword:
+        return QuotedKeyword(node[1])
+    if type(node[1]) is list:
+        return Quoted(node[1])
     return node[1]
 
 
@@ -1082,8 +1179,8 @@ def syn_and(env: Env, node: list) -> Any:
 
     if is_boolarr(first):
         vals = [first] + [my_eval(env, n) for n in node[2:]]
-        check_args(node[0], vals, (2, None), [is_boolarr])
-        return reduce(lambda a, b: boolop(a, b, np.logical_and), vals)
+        check_args(node[0], vals, (2, None), (is_boolarr,))
+        return reduce(lambda a, b: boolop(a, b, logical_and), vals)
 
     raise MyError(f"{node[0]} expects (or/c bool? bool-array?)")
 
@@ -1106,8 +1203,8 @@ def syn_or(env: Env, node: list) -> Any:
 
     if is_boolarr(first):
         vals = [first] + [my_eval(env, n) for n in node[2:]]
-        check_args(node[0], vals, (2, None), [is_boolarr])
-        return reduce(lambda a, b: boolop(a, b, np.logical_or), vals)
+        check_args(node[0], vals, (2, None), (is_boolarr,))
+        return reduce(lambda a, b: boolop(a, b, logical_or), vals)
 
     raise MyError(f"{node[0]} expects (or/c bool? bool-array?)")
 
@@ -1224,15 +1321,33 @@ def syn_let_star(env: Env, node: list) -> Any:
     return my_eval(inner_env, node[-1])
 
 
+def syn_class(env: Env, node: list) -> Any:
+    ...
+
+
 def attr(env: Env, node: list) -> Any:
     guard_term(node, 3, 3)
 
-    if not isinstance(node[2], Sym):
+    if type(node[2]) is not Sym:
         raise MyError("@r: attribute must be an identifier")
 
     return my_eval(env, [node[2], node[1]])
 
 
+def edit_none() -> np.ndarray:
+    if "@levels" not in env:
+        raise MyError("Can't use `none` if there's no input media")
+
+    return env["@levels"].none()
+
+
+def edit_all() -> np.ndarray:
+    if "@levels" not in env:
+        raise MyError("Can't use `all/e` if there's no input media")
+
+    return env["@levels"].all()
+
+
 def my_eval(env: Env, node: object) -> Any:
     if type(node) is Sym:
         val = env.get(node.val)
@@ -1251,10 +1366,9 @@ def my_eval(env: Env, node: object) -> Any:
             raise MyError("Can't use edit methods if there's no input files")
         return edit_method(node.val, env["@filesetup"], env)
 
-    if isinstance(node, list):
+    if type(node) is list:
         if not node:
             raise MyError("Illegal () expression")
-
         if node[0] is list:  # Handle vector literal
             return [my_eval(env, item) for item in node[1]]
 
@@ -1280,13 +1394,7 @@ def my_eval(env: Env, node: object) -> Any:
         if type(oper) is Syntax:
             return oper(env, node)
 
-        values = [my_eval(env, c) for c in node[1:]]
-        if type(oper) is Contract:
-            check_args(oper.name, values, (1, 1), None)
-        else:
-            check_args(oper.name, values, oper.arity, oper.contracts)
-
-        return oper(*values)
+        return oper(*(my_eval(env, c) for c in node[1:]))
 
     return node
 
@@ -1298,6 +1406,9 @@ env.update({
     "true": True,
     "false": False,
     "all": Sym("all"),
+    # edit procedures
+    "none": Proc("none", edit_none, (0, 0)),
+    "all/e": Proc("all/e", edit_all, (0, 0)),
     # syntax
     "lambda": Syntax(syn_lambda),
     "λ": Syntax(syn_lambda),
@@ -1306,6 +1417,7 @@ env.update({
     "set!": Syntax(syn_set),
     "incf": Syntax(syn_incf),
     "decf": Syntax(syn_decf),
+    "&=": Syntax(syn_strappend),
     "quote": Syntax(syn_quote),
     "if": Syntax(syn_if),
     "when": Syntax(syn_when),
@@ -1313,6 +1425,7 @@ env.update({
     "case": Syntax(syn_case),
     "let": Syntax(syn_let),
     "let*": Syntax(syn_let_star),
+    #"class": Syntax(syn_class),
     "@r": Syntax(attr),
     # loops
     "for": Syntax(syn_for),
@@ -1320,10 +1433,11 @@ env.update({
     "number?": is_num,
     "real?": is_real,
     "int?": is_int,
-    "uint?": is_uint,
-    "nat?": is_nat,
     "float?": is_float,
     "frac?": is_frac,
+    "complex?": Contract("complex?", lambda v: type(v) is complex),
+    "nat?": is_nat,
+    "nat1?": is_nat1,
     "threshold?": is_threshold,
     "any": any_p,
     "bool?": is_bool,
@@ -1331,7 +1445,7 @@ env.update({
     "symbol?": (is_symbol := Contract("symbol?", lambda v: type(v) is Sym)),
     "string?": is_str,
     "char?": (is_char := Contract("char?", lambda v: type(v) is Char)),
-    "vector?": (is_vector := Contract("vector?", lambda v: isinstance(v, list))),
+    "vector?": (is_vector := Contract("vector?", lambda v: type(v) is list)),
     "array?": (is_array := Contract("array?", lambda v: isinstance(v, np.ndarray))),
     "bool-array?": is_boolarr,
     "range?": (is_range := Contract("range?", lambda v: type(v) is range)),
@@ -1343,157 +1457,162 @@ env.update({
     "begin": Proc("begin", lambda *x: x[-1] if x else None, (0, None)),
     "void": Proc("void", lambda *v: None, (0, 0)),
     # control / b-arrays
-    "not": Proc(
-        "not",
-        lambda v: not v if type(v) is bool else np.logical_not(v),
-        (1, 1),
-        [bool_or_barr],
-    ),
+    "not": Proc("not", lambda v: not v if type(v) is bool else logical_not(v), (1, 1), bool_or_barr),
     "and": Syntax(syn_and),
     "or": Syntax(syn_or),
-    "xor": Proc("xor", _xor, (2, None), [bool_or_barr]),
+    "xor": Proc("xor", _xor, (2, None), bool_or_barr),
     # booleans
-    ">": Proc(">", lambda a, b: a > b, (2, 2), [is_real, is_real]),
-    ">=": Proc(">=", lambda a, b: a >= b, (2, 2), [is_real, is_real]),
-    "<": Proc("<", lambda a, b: a < b, (2, 2), [is_real, is_real]),
-    "<=": Proc("<=", lambda a, b: a <= b, (2, 2), [is_real, is_real]),
-    "=": Proc("=", equal_num, (1, None), [is_num]),
+    ">": Proc(">", lambda a, b: a > b, (2, 2), is_real),
+    ">=": Proc(">=", lambda a, b: a >= b, (2, 2), is_real),
+    "<": Proc("<", lambda a, b: a < b, (2, 2), is_real),
+    "<=": Proc("<=", lambda a, b: a <= b, (2, 2), is_real),
+    "=": Proc("=", equal_num, (1, None), is_num),
     "eq?": Proc("eq?", lambda a, b: a is b, (2, 2)),
     "equal?": Proc("equal?", is_equal, (2, 2)),
-    "zero?": UserProc(env, "zero?", ["z"], [[Sym("="), Sym("z"), 0]], [is_num]),
-    "positive?": UserProc(
-        env, "positive?", ["x"], [[Sym(">"), Sym("x"), 0]], [is_real]
-    ),
-    "negative?": UserProc(
-        env, "negative?", ["x"], [[Sym("<"), Sym("x"), 0]], [is_real]
-    ),
+    "zero?": UserProc(env, "zero?", ["z"], (is_num,), [[Sym("="), Sym("z"), 0]]),
+    "positive?": UserProc(env, "positive?", ["x"], (is_real,), [[Sym(">"), Sym("x"), 0]]),
+    "negative?": UserProc(env, "negative?", ["x"], (is_real,), [[Sym("<"), Sym("x"), 0]]),
     "even?": UserProc(
-        env, "even?", ["n"], [[Sym("zero?"), [Sym("mod"), Sym("n"), 2]]], [is_int]
+        env, "even?", ["n"], (is_int,), [[Sym("zero?"), [Sym("mod"), Sym("n"), 2]]]
     ),
     "odd?": UserProc(
-        env, "odd?", ["n"], [[Sym("not"), [Sym("even?"), Sym("n")]]], [is_int]
+        env, "odd?", ["n"], (is_int,), [[Sym("not"), [Sym("even?"), Sym("n")]]]
     ),
-    ">=/c": Proc(">=/c", gte_c, (1, 1), [is_real]),
-    ">/c": Proc(">/c", gt_c, (1, 1), [is_real]),
-    "<=/c": Proc("<=/c", lte_c, (1, 1), [is_real]),
-    "</c": Proc("</c", lt_c, (1, 1), [is_real]),
-    "between/c": Proc("between/c", between_c, (2, 2), [is_real, is_real]),
+    ">=/c": Proc(">=/c", gte_c, (1, 1), is_real),
+    ">/c": Proc(">/c", gt_c, (1, 1), is_real),
+    "<=/c": Proc("<=/c", lte_c, (1, 1), is_real),
+    "</c": Proc("</c", lt_c, (1, 1), is_real),
+    "between/c": Proc("between/c", between_c, (2, 2), is_real),
     # numbers
-    "+": Proc("+", lambda *v: sum(v), (0, None), [is_num]),
-    "-": Proc("-", minus, (1, None), [is_num]),
-    "*": Proc("*", mul, (0, None), [is_num]),
-    "/": Proc("/", num_div, (1, None), [is_num]),
-    "div": Proc("div", int_div, (2, None), [is_int]),
-    "add1": Proc("add1", lambda z: z + 1, (1, 1), [is_num]),
-    "sub1": Proc("sub1", lambda z: z - 1, (1, 1), [is_num]),
-    "sqrt": Proc("sqrt", _sqrt, (1, 1), [is_num]),
-    "real-part": Proc("real-part", lambda v: v.real, (1, 1), [is_num]),
-    "imag-part": Proc("imag-part", lambda v: v.imag, (1, 1), [is_num]),
+    "+": Proc("+", lambda *v: sum(v), (0, None), is_num),
+    "-": Proc("-", minus, (1, None), is_num),
+    "*": Proc("*", mul, (0, None), is_num),
+    "/": Proc("/", num_div, (1, None), is_num),
+    "div": Proc("div", int_div, (2, None), is_int),
+    "add1": Proc("add1", lambda z: z + 1, (1, 1), is_num),
+    "sub1": Proc("sub1", lambda z: z - 1, (1, 1), is_num),
+    "sqrt": Proc("sqrt", _sqrt, (1, 1), is_num),
+    "real-part": Proc("real-part", lambda v: v.real, (1, 1), is_num),
+    "imag-part": Proc("imag-part", lambda v: v.imag, (1, 1), is_num),
     # reals
-    "pow": Proc("pow", pow, (2, 2), [is_real]),
-    "exp": Proc("exp", math.exp, (1, 1), [is_real]),
-    "abs": Proc("abs", abs, (1, 1), [is_real]),
-    "ceil": Proc("ceil", math.ceil, (1, 1), [is_real]),
-    "floor": Proc("floor", math.floor, (1, 1), [is_real]),
-    "round": Proc("round", round, (1, 1), [is_real]),
-    "max": Proc("max", lambda *v: max(v), (1, None), [is_real]),
-    "min": Proc("min", lambda *v: min(v), (1, None), [is_real]),
-    "sin": Proc("sin", math.sin, (1, 1), [is_real]),
-    "cos": Proc("cos", math.cos, (1, 1), [is_real]),
-    "log": Proc("log", math.log, (1, 2), [is_real, is_real]),
-    "tan": Proc("tan", math.tan, (1, 1), [is_real]),
-    "mod": Proc("mod", lambda a, b: a % b, (2, 2), [is_int]),
-    "modulo": Proc("modulo", lambda a, b: a % b, (2, 2), [is_int]),
+    "pow": Proc("pow", pow, (2, 2), is_real),
+    "exp": Proc("exp", math.exp, (1, 1), is_real),
+    "abs": Proc("abs", abs, (1, 1), is_real),
+    "ceil": Proc("ceil", math.ceil, (1, 1), is_real),
+    "floor": Proc("floor", math.floor, (1, 1), is_real),
+    "round": Proc("round", round, (1, 1), is_real),
+    "max": Proc("max", lambda *v: max(v), (1, None), is_real),
+    "min": Proc("min", lambda *v: min(v), (1, None), is_real),
+    "sin": Proc("sin", math.sin, (1, 1), is_real),
+    "cos": Proc("cos", math.cos, (1, 1), is_real),
+    "log": Proc("log", math.log, (1, 2), is_real),
+    "tan": Proc("tan", math.tan, (1, 1), is_real),
+    "mod": Proc("mod", lambda a, b: a % b, (2, 2), is_int),
+    "modulo": Proc("modulo", lambda a, b: a % b, (2, 2), is_int),
     # symbols
-    "symbol->string": Proc("symbol->string", str, (1, 1), [is_symbol]),
-    "string->symbol": Proc("string->symbol", Sym, (1, 1), [is_str]),
+    "symbol->string": Proc("symbol->string", str, (1, 1), is_symbol),
+    "string->symbol": Proc("string->symbol", Sym, (1, 1), is_str),
     # strings
-    "string": Proc("string", string_append, (0, None), [is_char]),
-    "string-append": Proc("string-append", string_append, (0, None), [is_str]),
-    "split": Proc("split", str.split, (1, 2), [is_str, is_str]),
-    "strip": Proc("strip", str.strip, (1, 1), [is_str]),
-    "str-repeat": Proc("str-repeat", lambda s, a: s * a, (2, 2), [is_str, is_int]),
-    "startswith": Proc("startswith", str.startswith, (2, 2), [is_str, is_str]),
-    "endswith": Proc("endswith", str.endswith, (2, 2), [is_str, is_str]),
-    "replace": Proc("replace", str.replace, (3, 4), [is_str, is_str, is_str, is_int]),
-    "title": Proc("title", str.title, (1, 1), [is_str]),
-    "lower": Proc("lower", str.lower, (1, 1), [is_str]),
-    "upper": Proc("upper", str.upper, (1, 1), [is_str]),
+    "string": Proc("string", string_append, (0, None), is_char),
+    "&": Proc("&", string_append, (0, None), is_str),
+    "split": Proc("split", str.split, (1, 2), is_str, is_str),
+    "strip": Proc("strip", str.strip, (1, 1), is_str),
+    "str-repeat": Proc("str-repeat", lambda s, a: s * a, (2, 2), is_str, is_int),
+    "startswith": Proc("startswith", str.startswith, (2, 2), is_str),
+    "endswith": Proc("endswith", str.endswith, (2, 2), is_str),
+    "replace": Proc("replace", str.replace, (3, 4), is_str, is_str, is_str, is_int),
+    "title": Proc("title", str.title, (1, 1), is_str),
+    "lower": Proc("lower", str.lower, (1, 1), is_str),
+    "upper": Proc("upper", str.upper, (1, 1), is_str),
+    "join": Proc("join", palet_join, (2, 2), is_vector, is_str),
     # format
-    "char->int": Proc("char->int", lambda c: ord(c.val), (1, 1), [is_char]),
-    "int->char": Proc("int->char", Char, (1, 1), [is_int]),
+    "char->int": Proc("char->int", lambda c: ord(c.val), (1, 1), is_char),
+    "int->char": Proc("int->char", Char, (1, 1), is_int),
     "~a": Proc("~a", lambda *v: "".join([display_str(a) for a in v]), (0, None)),
     "~s": Proc("~s", lambda *v: " ".join([display_str(a) for a in v]), (0, None)),
     "~v": Proc("~v", lambda *v: " ".join([print_str(a) for a in v]), (0, None)),
+    # keyword
+    "keyword?": is_keyw,
+    "keyword->string": Proc("keyword->string", lambda v: v.val.val, (1, 1), is_keyw),
+    "string->keyword": Proc("string->keyword", QuotedKeyword, (1, 1), is_str),
     # vectors
     "vector": Proc("vector", lambda *a: list(a), (0, None)),
     "make-vector": Proc(
-        "make-vector", lambda size, a=0: [a] * size, (1, 2), [is_uint, any_p]
+        "make-vector", lambda size, a=0: [a] * size, (1, 2), is_nat, any_p
     ),
-    "vector-append": Proc("vector-append", vector_append, (0, None), [is_vector]),
-    "vector-pop!": Proc("vector-pop!", list.pop, (1, 1), [is_vector]),
-    "vector-add!": Proc("vector-add!", list.append, (2, 2), [is_vector, any_p]),
-    "vector-set!": Proc("vector-set!", vector_set, (3, 3), [is_vector, is_int, any_p]),
-    "vector-extend!": Proc("vector-extend!", vector_extend, (2, None), [is_vector]),
-    "sort": Proc("sort", sorted, (1, 1), [is_vector]),
-    "sort!": Proc("sort!", list.sort, (1, 1), [is_vector]),
+    "add!": Proc("add!", list.append, (2, 2), is_vector, any_p),
+    "pop!": Proc("pop!", list.pop, (1, 1), is_vector),
+    "vec-set!": Proc("vec-set!", vector_set, (3, 3), is_vector, is_int, any_p),
+    "vec-append": Proc("vec-append", vector_append, (0, None), is_vector),
+    "vec-extend!": Proc("vec-extend!", vector_extend, (2, None), is_vector),
+    "sort": Proc("sort", sorted, (1, 1), is_vector),
+    "sort!": Proc("sort!", list.sort, (1, 1), is_vector),
     # arrays
-    "array": Proc("array", array_proc, (2, None), [is_symbol, is_real]),
-    "make-array": Proc("make-array", make_array, (2, 3), [is_symbol, is_uint, is_real]),
+    "array": Proc("array", array_proc, (2, None), is_symbol, is_real),
+    "make-array": Proc("make-array", make_array, (2, 3), is_symbol, is_nat, is_real),
     "array-splice!": Proc(
-        "array-splice!", splice, (2, 4), [is_array, is_real, is_int, is_int]
+        "array-splice!", splice, (2, 4), is_array, is_real, is_int, is_int
     ),
-    "array-copy": Proc("array-copy", np.copy, (1, 1), [is_array]),
-    "count-nonzero": Proc("count-nonzero", np.count_nonzero, (1, 1), [is_array]),
+    "array-copy": Proc("array-copy", np.copy, (1, 1), is_array),
+    "count-nonzero": Proc("count-nonzero", np.count_nonzero, (1, 1), is_array),
     # bool arrays
     "bool-array": Proc(
-        "bool-array", lambda *a: np.array(a, dtype=np.bool_), (1, None), [is_uint]
+        "bool-array", lambda *a: np.array(a, dtype=np.bool_), (1, None), is_nat
     ),
-    "margin": Proc("margin", margin, (2, 3), None),
-    "mincut": Proc("mincut", mincut, (2, 2), [is_boolarr, is_uint]),
-    "minclip": Proc("minclip", minclip, (2, 2), [is_boolarr, is_uint]),
-    "maxcut": Proc("maxcut", maxcut, (2, 2), [is_boolarr, is_uint]),
-    "maxclip": Proc("maxclip", maxclip, (2, 2), [is_boolarr, is_uint]),
+    "margin": Proc("margin", margin, (2, 3)),
+    "mincut": Proc("mincut", mincut, (2, 2), is_boolarr, is_nat),
+    "minclip": Proc("minclip", minclip, (2, 2), is_boolarr, is_nat),
+    "maxcut": Proc("maxcut", maxcut, (2, 2), is_boolarr, is_nat),
+    "maxclip": Proc("maxclip", maxclip, (2, 2), is_boolarr, is_nat),
     # ranges
-    "range": Proc("range", range, (1, 3), [is_int, is_int, int_not_zero]),
+    "range": Proc("range", range, (1, 3), is_int, is_int, int_not_zero),
     # generic iterables
-    "len": Proc("len", len, (1, 1), [is_iterable]),
-    "reverse": Proc("reverse", lambda v: v[::-1], (1, 1), [is_sequence]),
-    "ref": Proc("ref", ref, (2, 2), [is_sequence, is_int]),
-    "slice": Proc("slice", p_slice, (2, 4), [is_sequence, is_int]),
+    "len": Proc("len", len, (1, 1), is_iterable),
+    "reverse": Proc("reverse", lambda v: v[::-1], (1, 1), is_sequence),
+    "ref": Proc("ref", ref, (2, 2), is_sequence, is_int),
+    "slice": Proc("slice", p_slice, (2, 4), is_sequence, is_int),
     # procedures
-    "map": Proc("map", palet_map, (2, 2), [is_proc, is_sequence]),
-    "apply": Proc("apply", apply, (2, 2), [is_proc, is_sequence]),
-    "and/c": Proc("and/c", andc, (1, None), [is_cont]),
-    "or/c": Proc("or/c", orc, (1, None), [is_cont]),
-    "not/c": Proc("not/c", notc, (1, 1), [is_cont]),
+    "map": Proc("map", palet_map, (2, 2), is_proc, is_sequence),
+    "apply": Proc("apply", lambda p, s: p(*s), (2, 2), is_proc, is_sequence),
+    "and/c": Proc("and/c", andc, (1, None), is_cont),
+    "or/c": Proc("or/c", orc, (1, None), is_cont),
+    "not/c": Proc("not/c", notc, (1, 1), is_cont),
     # hashs
     "hash": Proc("hash", palet_hash, (0, None)),
-    "hash-ref": Proc("hash", hash_ref, (2, 2), [is_hash, any_p]),
-    "hash-set!": Proc("hash-set!", hash_set, (3, 3), [is_hash, any_p, any_p]),
-    "has-key?": Proc("has-key?", lambda h, k: k in h, (2, 2), [is_hash, any_p]),
-    "hash-remove!": Proc("hash-remove!", hash_remove, (2, 2), [is_hash, any_p]),
-    "hash-update!": UserProc(env, "hash-update!", ["h", "v", "up"],
+    "hash-ref": Proc("hash", hash_ref, (2, 2), is_hash, any_p),
+    "hash-set!": Proc("hash-set!", hash_set, (3, 3), is_hash, any_p, any_p),
+    "has-key?": Proc("has-key?", lambda h, k: k in h, (2, 2), is_hash, any_p),
+    "hash-remove!": Proc("hash-remove!", hash_remove, (2, 2), is_hash, any_p),
+    "hash-update!": UserProc(env, "hash-update!", ["h", "v", "up"], (is_hash, any_p),
         [[Sym("hash-set!"), Sym("h"), Sym("v"), [Sym("up"), [Sym("hash-ref"), Sym("h"), Sym("v")]]]],
-        [is_hash, any_p, any_p],
     ),
+    # i/o
+    "open-output-file": Proc("open-output-file", initOutPort, (1, 1), is_str),
+    "output-port?": (op := Contract("output-port?", lambda v: type(v) is OutputPort)),
+    "close-port": Proc("close-port", OutputPort.close, (1, 1), op),
+    "closed?": Proc("closed?", lambda o: o.closed, (1, 1), op),
+    # printing
+    "display": Proc("display",
+        lambda v, f=None: print(display_str(v), end="", file=f), (1, 2), any_p, op),
+    "displayln": Proc("displayln",
+        lambda v, f=None: print(display_str(v), file=f), (1, 2), any_p, op),
+    "print": Proc("print",
+        lambda v, f=None: print(print_str(v), end="", file=f), (1, 2), any_p, op),
+    "println": Proc("println",
+        lambda v, f=None: print(print_str(v), file=f), (1, 2), any_p, op),
     # actions
-    "assert": Proc("assert", palet_assert, (1, 2), [any_p, orc(is_str, False)]),
-    "display": Proc("display", lambda v: print(display_str(v), end=""), (1, 1)),
-    "displayln": Proc("displayln", lambda v: print(display_str(v)), (1, 1)),
-    "error": Proc("error", raise_, (1, 1), [is_str]),
-    "sleep": Proc("sleep", sleep, (1, 1), [is_int_or_float]),
-    "print": Proc("print", lambda v: print(print_str(v), end=""), (1, 1)),
-    "println": Proc("println", lambda v: print(print_str(v)), (1, 1)),
-    "system": Proc("system", palet_system, (1, 1)),
+    "assert": Proc("assert", palet_assert, (1, 2), any_p, orc(is_str, False)),
+    "error": Proc("error", raise_, (1, 1), is_str),
+    "sleep": Proc("sleep", sleep, (1, 1), is_int_or_float),
+    "system": Proc("system", palet_system, (1, 1), is_str),
     # conversions
-    "number->string": Proc("number->string", number_to_string, (1, 1), [is_num]),
+    "number->string": Proc("number->string", number_to_string, (1, 1), is_num),
     "string->vector": Proc(
-        "string->vector", lambda s: [Char(c) for c in s], (1, 1), [is_str]
+        "string->vector", lambda s: [Char(c) for c in s], (1, 1), is_str
     ),
-    "range->vector": Proc("range->vector", list, (1, 1), [is_range]),
+    "range->vector": Proc("range->vector", list, (1, 1), is_range),
     # reflexion
-    "var-exists?": Proc("var-exists?", lambda sym: sym.val in env, (1, 1), [is_symbol]),
+    "var-exists?": Proc("var-exists?", lambda sym: sym.val in env, (1, 1), is_symbol),
     "rename": Syntax(syn_rename),
     "delete": Syntax(syn_delete),
 })
@@ -1504,4 +1623,7 @@ def interpret(env: Env, parser: Parser) -> list:
     result = []
     while parser.current_token.type != EOF:
         result.append(my_eval(env, parser.expr()))
+
+        if type(result[-1]) is Keyword:
+            raise MyError(f"Keyword misused in expression. `{result[-1]}`")
     return result