remove bad file

1 files changed, 0 insertions, 940 deletions

diff --git a/all_files b/all_files
deleted file mode 100644
index 57024cc..0000000
--- a/all_files
+++ /dev/null
@@ -1,940 +0,0 @@
-export * from "./lang";
-export * from "./ts-lang";
-export * from "./ks-lang";
-export * from "./js-lang";
-type BUILTIN = (args: any[]) => any;
-
-export const V_BUILTIN_Arr: BUILTIN = (args) => args;
-
-// FIXME actually implement this properly
-export const V_BUILTIN_ToString: BUILTIN = (args) =>
-  args.length === 1 ? JSON.stringify(args[0]) : JSON.stringify(args);
-
-export const V_BUILTIN_Add: BUILTIN = (args) => {
-  if (args.every((arg) => ["string", "number"].includes(typeof arg))) {
-    return args.reduce(
-      (acc, cur) => acc + cur,
-      typeof args[0] === "string" ? "" : 0
-    );
-  }
-
-  throw new Error(`Cannot add operands ${JSON.stringify(args, undefined, 2)}`);
-};
-
-export const V_BUILTIN_Mul: BUILTIN = (args) => {
-  if (args.every((arg) => typeof arg === "number") && args.length === 2) {
-    return args.reduce((acc, cur) => acc * cur, 1);
-  }
-
-  throw new Error(
-    `Can only multiply [number, number], but got ${JSON.stringify(
-      args,
-      undefined,
-      2
-    )}`
-  );
-};
-
-export const nameToBUILTIN: Record<string, BUILTIN> = {
-  arr: V_BUILTIN_Arr,
-  tostring: V_BUILTIN_ToString,
-  add: V_BUILTIN_Add,
-  mul: V_BUILTIN_Mul,
-};
-export * from "./builtin";
-export * from "./sbuiltin";
-import { callFn, getEvaluatedChildren } from "../core/eval";
-import { ASTNode, FnPrim, StackFrame } from "../../ts-lang";
-
-type SBUILTIN = (node: ASTNode, frame: StackFrame) => any;
-
-export const V_SBUILTIN_Call: SBUILTIN = (node, frame) => {
-  const children = getEvaluatedChildren(node, frame);
-  const fn = children[0] as FnPrim | undefined;
-
-  if (!fn?.fn) {
-    throw new Error(
-      `Invalid params for function call: ${JSON.stringify(
-        children,
-        undefined,
-        2
-      )}`
-    );
-  }
-
-  return callFn(fn, children.slice(1), frame);
-};
-
-export const V_SBUILTIN_Map: SBUILTIN = (node, frame) => {
-  const children = getEvaluatedChildren(node, frame);
-  const fn = children[1] as FnPrim | undefined;
-
-  if (!fn?.fn) {
-    throw new Error(
-      `Invalid params for map: ${JSON.stringify(children, undefined, 2)}`
-    );
-  }
-
-  const values = children[0];
-
-  if (!Array.isArray(values)) {
-    // add to ts
-    throw new Error(`Can't map non-array value: ${values}`);
-  }
-
-  return values.map((v, i) => callFn(fn, [v, i], frame));
-};
-
-export const nameToSBUILTIN: Record<string, SBUILTIN> = {
-  call: V_SBUILTIN_Call,
-  map: V_SBUILTIN_Map,
-};
-import {
-  ASTNode,
-  StackFrame,
-  Evaluate,
-  EmptyStackFrame,
-  NodeType,
-  FnPrim,
-  SENTINEL_NO_BUILTIN,
-} from "../../ts-lang";
-import { nameToBUILTIN, nameToSBUILTIN, V_SBUILTIN_Map } from "../builtin";
-
-const V_SENTINEL_NO_BUILTIN: SENTINEL_NO_BUILTIN = "__NO_BUILTIN__";
-
-const mapBuiltins = (node: ASTNode, frame: StackFrame): any => {
-  if (node.name in nameToSBUILTIN) {
-    return nameToSBUILTIN[node.name](node, frame);
-  }
-  if (node.name in nameToBUILTIN) {
-    return nameToBUILTIN[node.name](getEvaluatedChildren(node, frame));
-  }
-
-  return V_SENTINEL_NO_BUILTIN;
-};
-
-const findInStack = (frame: StackFrame, nameToFind: string) => {
-  if (nameToFind in frame.bindings) {
-    return frame.bindings[nameToFind];
-  }
-
-  if (!frame.parent) {
-    throw new Error(`Can't find name ${nameToFind} on the stack`);
-  }
-
-  return findInStack(frame.parent, nameToFind);
-};
-
-const handleFn = (node: ASTNode): FnPrim => {
-  const fn = node.children[node.children.length - 1];
-
-  return {
-    args: node.children.slice(0, node.children.length - 1),
-    fn,
-  };
-};
-
-const mapZip = (args: ASTNode[], values: any[]) =>
-  Object.fromEntries(args.map(({ name }, i) => [name, values[i]]));
-
-export const callFn = (fn: FnPrim, values: any[], frame: StackFrame) =>
-  _evaluate(fn.fn, {
-    bindings: mapZip(fn.args as ASTNode[], values),
-    parent: frame,
-  });
-
-export const _evaluate = (node: ASTNode, frame: StackFrame) => {
-  if (node.type === NodeType.INT) {
-    return node.value;
-  }
-
-  if (node.type === NodeType.EXT) {
-    if (node.name === "fn") {
-      return handleFn(node);
-    }
-
-    const builtinResult = mapBuiltins(node, frame);
-    if (builtinResult !== V_SENTINEL_NO_BUILTIN) {
-      return builtinResult;
-    }
-
-    return findInStack(frame, node.name);
-  }
-
-  throw new Error(`Unhandled node type ${node.type}`);
-};
-
-export const getEvaluatedChildren = (node: ASTNode, frame: StackFrame) =>
-  node.children.map((child) => _evaluate(child, frame));
-
-export const emptyStackFrame: EmptyStackFrame = { bindings: {}, parent: null };
-
-export const evaluate = <const Node extends ASTNode>(
-  node: Node
-): Evaluate<Node> => _evaluate(node, emptyStackFrame) as Evaluate<Node>;
-export * from "./eval";
-export * from "./parser";
-export * from "./lexer";
-import { TokenType, Lex, Token } from "../../ts-lang";
-
-const WHITESPACE_TOKENS = [
-  TokenType.SPACE,
-  TokenType.COMMA,
-  TokenType.SEMICOLON,
-] as string[];
-
-export const lex = <const Raw extends string>(raw: Raw): Lex<Raw> => {
-  let _raw: string = raw;
-  let nameCollection = "";
-  const tokens: Token[] = [];
-
-  while (_raw) {
-    const head = _raw[0];
-    _raw = _raw.slice(1);
-
-    const processNameCollection = () => {
-      if (nameCollection) {
-        tokens.push({ type: TokenType.NAME, name: nameCollection });
-        nameCollection = "";
-      }
-    };
-
-    if (WHITESPACE_TOKENS.includes(head)) {
-      processNameCollection();
-      continue;
-    }
-
-    if (head === TokenType.OPEN_PAREN) {
-      processNameCollection();
-      tokens.push({ type: TokenType.OPEN_PAREN, name: "" });
-      continue;
-    }
-
-    if (head === TokenType.CLOSE_PAREN) {
-      processNameCollection();
-      tokens.push({ type: TokenType.CLOSE_PAREN, name: "" });
-      continue;
-    }
-
-    nameCollection += head;
-  }
-
-  return tokens as Lex<Raw>;
-};
-import { Token, Parse, TokenType, ASTNode, NodeType } from "../../ts-lang";
-import { lex } from "./lexer";
-
-const resolveNodeFromToken = (token: Token): ASTNode => {
-  // FIXME not correct
-  if (!isNaN(Number(token.name))) {
-    return {
-      type: NodeType.INT,
-      name: "",
-      value: Number(token.name),
-      children: [],
-    };
-  }
-  if (token.name[0] === '"' && token.name[token.name.length - 1] === '"') {
-    return {
-      type: NodeType.INT,
-      name: "",
-      value: token.name.slice(1, token.name.length - 1),
-      children: [],
-    };
-  }
-  return {
-    type: NodeType.EXT,
-    name: token.name,
-    value: null,
-    children: [],
-  };
-};
-
-const _parse = ({
-  remainingTokens,
-  lastToken,
-  stack,
-}: {
-  remainingTokens: Token[];
-  lastToken: Token | null;
-  stack: ASTNode[];
-}): ASTNode | null => {
-  const head = remainingTokens.shift();
-  if (!head) {
-    if (lastToken) {
-      (stack[stack.length - 1].children as ASTNode[]).push(
-        resolveNodeFromToken(lastToken)
-      );
-
-      return _parse({
-        lastToken: null,
-        remainingTokens: [],
-        stack,
-      });
-    }
-
-    return stack[0] ?? null;
-  }
-
-  if (lastToken) {
-    if (head.type === TokenType.NAME) {
-      (stack[stack.length - 1].children as ASTNode[]).push(
-        resolveNodeFromToken(lastToken)
-      );
-      return _parse({
-        lastToken: head,
-        remainingTokens,
-        stack,
-      });
-    }
-
-    if (head.type === TokenType.CLOSE_PAREN) {
-      const top = stack.pop()!;
-      (top.children as ASTNode[]).push(resolveNodeFromToken(lastToken));
-      (stack[stack.length - 1].children as ASTNode[]).push(top);
-
-      return _parse({
-        lastToken: null,
-        remainingTokens,
-        stack,
-      });
-    }
-
-    if (head.type === TokenType.OPEN_PAREN) {
-      return _parse({
-        lastToken: null,
-        remainingTokens,
-        stack: [...stack, resolveNodeFromToken(lastToken)],
-      });
-    }
-
-    throw new Error(
-      `${JSON.stringify({
-        lastToken,
-        remainingTokens,
-        stack,
-      })} Was not expecting ${head.type}`
-    );
-  }
-
-  if (head.type === TokenType.NAME) {
-    return _parse({
-      lastToken: head,
-      remainingTokens,
-      stack,
-    });
-  }
-
-  if (head.type === TokenType.CLOSE_PAREN) {
-    const top = stack.pop()!;
-    (stack[stack.length - 1].children as ASTNode[]).push(top);
-
-    return _parse({
-      lastToken: null,
-      remainingTokens,
-      stack,
-    });
-  }
-
-  throw new Error(
-    `${JSON.stringify({
-      lastToken,
-      remainingTokens,
-      stack,
-    })} Expected nextToken to be a name or close paren at ${head.type}`
-  );
-};
-
-export const parse = <const Raw extends readonly Token[]>(
-  raw: Raw
-): Parse<Raw> =>
-  _parse({
-    remainingTokens: raw as unknown as Token[],
-    lastToken: null,
-    stack: [{ type: NodeType.EXT, name: "arr", value: null, children: [] }],
-  }) as Parse<Raw>;
-export * from "./core";
-import { callFn, emptyStackFrame, evaluate, lex, parse } from "../js-lang";
-import {
-  Evaluate,
-  FnPrim,
-  Lex,
-  Parse,
-  EvalError,
-  CallFn,
-  EmptyStackFrame,
-} from "../ts-lang";
-
-export const createFn = <Program extends string>(
-  program: Program
-): Evaluate<Parse<Lex<Program>>> extends [infer ProgramFn extends FnPrim]
-  ? <const Args extends any[]>(
-      ...args: Args
-    ) => CallFn<ProgramFn, Args, EmptyStackFrame>
-  : EvalError<"Cannot create a function from a program that does not eval to a function"> => {
-  const [programFn] = evaluate(parse(lex(program))) as Array<FnPrim>;
-  if (!programFn.fn) {
-    throw new Error(
-      "Cannot create a function from a program that does not eval to a function"
-    );
-  }
-
-  return ((...args: any[]) => callFn(programFn, args, emptyStackFrame)) as any;
-};
-import { FnError } from ".";
-import {
-  AddNumbers,
-  AddStrings,
-  Multiply,
-  ToString,
-  UnarrayIfOnlyHead,
-} from "../util";
-
-export type BUILTIN_Arr<Args extends readonly any[]> = Args;
-
-export type BUILTIN_ToString<Args extends readonly any[]> = ToString<
-  UnarrayIfOnlyHead<{
-    [Idx in keyof Args]: ToString<Args[Idx]>;
-  }>
->;
-
-export type BUILTIN_Add<Args extends readonly any[]> =
-  Args extends readonly string[]
-    ? AddStrings<Args>
-    : Args extends readonly number[]
-    ? AddNumbers<Args>
-    : FnError<`Cannot add operands ${ToString<Args>}`>;
-
-export type BUILTIN_Mul<Args extends readonly any[]> = Args extends [
-  infer A,
-  infer B,
-  infer C
-]
-  ? FnError<`Can only multiply [number, number], but got ${ToString<Args>}`>
-  : Args extends [infer M extends number, infer N extends number]
-  ? Multiply<M, N>
-  : FnError<`Can only multiply [number, number], but got ${ToString<Args>}`>;
-export type FnError<T extends string> = `Function execution error: ${T}`;
-export * from "./builtin";
-export * from "./sbuiltin";
-import { ASTNode, StackFrame } from "../core/common";
-import { CallFn, FnPrim, GetEvaluatedChildren, EvalError } from "../core/eval";
-import { ExtractNumber, ToString } from "../util";
-
-export type SBUILTIN_Call<
-  Node extends ASTNode,
-  Frame extends StackFrame
-> = GetEvaluatedChildren<Node, Frame> extends [
-  infer Fn extends FnPrim,
-  ...infer Values extends readonly any[]
-]
-  ? CallFn<Fn, Values, Frame>
-  : EvalError<`Invalid params for function call: ${ToString<
-      GetEvaluatedChildren<Node, Frame>
-    >}`>;
-
-export type SBUILTIN_Map<
-  Node extends ASTNode,
-  Frame extends StackFrame
-> = GetEvaluatedChildren<Node, Frame> extends [
-  infer Arr extends readonly any[],
-  infer Fn extends FnPrim
-]
-  ? { [Idx in keyof Arr]: CallFn<Fn, [Arr[Idx], ExtractNumber<Idx>], Frame> }
-  : EvalError<`Invalid params for map: ${ToString<
-      GetEvaluatedChildren<Node, Frame>
-    >}`>;
-export enum TokenType {
-  OPEN_PAREN = "(",
-  CLOSE_PAREN = ")",
-  SPACE = " ",
-  SEMICOLON = ";",
-  COMMA = ",",
-  NAME = "NAME",
-}
-
-export type Token<
-  Type extends TokenType = TokenType,
-  Name extends string = string
-> = {
-  type: Type;
-  name: Name;
-};
-
-export type LexerCtx = {
-  next: string;
-  nameCollection: string;
-  tokens: readonly Token[];
-};
-
-export enum NodeType {
-  INT = "INT",
-  EXT = "EXT",
-  PARSER_ERROR = "PARSER_ERROR",
-}
-
-export type ASTNode<
-  Type extends NodeType = NodeType,
-  Name extends string = string,
-  Value extends any = any,
-  Children extends readonly ASTNode[] = readonly ASTNode<
-    NodeType,
-    string,
-    any,
-    any
-  >[]
-> = {
-  type: Type;
-  name: Name;
-  value: Value;
-  children: Children;
-};
-
-export type ParserCtx = {
-  remainingTokens: readonly Token[];
-  lastToken: Token | null;
-  stack: readonly ASTNode[];
-};
-
-export type StackFrame<
-  Bindings extends Record<ASTNode["name"], any> = Record<ASTNode["name"], any>,
-  Parent extends StackFrame | null = any
-> = {
-  bindings: Bindings;
-  parent: Parent;
-};
-
-export type EmptyStackFrame = StackFrame<{}, null>;
-
-export type WithPushedBindings<
-  OldFrame extends StackFrame,
-  Bindings extends StackFrame["bindings"]
-> = StackFrame<Bindings, OldFrame>;
-import {
-  BUILTIN_Add,
-  BUILTIN_Arr,
-  BUILTIN_Mul,
-  BUILTIN_ToString,
-  SBUILTIN_Call,
-  SBUILTIN_Map,
-} from "../builtin";
-import { ToString } from "../util";
-import { ASTNode, EmptyStackFrame, NodeType, StackFrame } from "./common";
-
-export type SENTINEL_NO_BUILTIN = "__NO_BUILTIN__";
-export type MapBuiltins<
-  Node extends ASTNode,
-  Frame extends StackFrame
-> = GetEvaluatedChildren<Node, Frame> extends infer Args extends readonly any[]
-  ? Node["name"] extends "call"
-    ? SBUILTIN_Call<Node, Frame>
-    : Node["name"] extends "map"
-    ? SBUILTIN_Map<Node, Frame>
-    : Node["name"] extends "tostring"
-    ? BUILTIN_ToString<Args>
-    : Node["name"] extends "arr"
-    ? BUILTIN_Arr<Args>
-    : Node["name"] extends "add"
-    ? BUILTIN_Add<Args>
-    : Node["name"] extends "mul"
-    ? BUILTIN_Mul<Args>
-    : SENTINEL_NO_BUILTIN
-  : never;
-
-export type EvalError<T extends string> = `Eval error: ${T}`;
-
-export type FindInStack<
-  Frame extends StackFrame,
-  NameToFind
-> = NameToFind extends keyof Frame["bindings"]
-  ? Frame["bindings"][NameToFind]
-  : Frame["parent"] extends null
-  ? EvalError<`Can't find name "${ToString<NameToFind>}" on the stack`>
-  : FindInStack<Frame["parent"], NameToFind>;
-
-export type FnPrim<
-  Args extends readonly ASTNode[] = readonly ASTNode[],
-  Fn extends ASTNode = ASTNode
-> = { args: Args; fn: Fn };
-
-export type HandleFn<Node extends ASTNode> = Node["children"] extends [
-  ...infer Args extends ASTNode[],
-  infer Fn extends ASTNode
-]
-  ? FnPrim<Args, Fn>
-  : // error?
-    never;
-
-// any[] was propertykey
-export type MapZip<
-  Args extends readonly ASTNode[],
-  Values extends readonly any[]
-> = {
-  [Idx in Exclude<
-    keyof Args,
-    keyof any[]
-  > as Args[Idx] extends infer Node extends ASTNode
-    ? Node["name"]
-    : never]: Idx extends keyof Values ? Values[Idx] : never;
-};
-
-export type CallFn<
-  Fn extends FnPrim,
-  Values extends readonly any[],
-  Frame extends StackFrame
-> = _Evaluate<Fn["fn"], StackFrame<MapZip<Fn["args"], Values>, Frame>>;
-
-export type _Evaluate<
-  Node extends ASTNode,
-  Frame extends StackFrame
-> = Node["type"] extends NodeType.INT
-  ? Node["value"]
-  : Node["type"] extends NodeType.EXT
-  ? // special builtin
-    Node["name"] extends "fn"
-    ? HandleFn<Node>
-    : MapBuiltins<Node, Frame> extends infer BI
-    ? BI extends SENTINEL_NO_BUILTIN
-      ? FindInStack<Frame, Node["name"]>
-      : BI
-    : never
-  : EvalError<`Unhandled node type ${Node["type"]}`>;
-
-export type GetEvaluatedChildren<
-  Node extends ASTNode,
-  Frame extends StackFrame
-> = Node["children"] extends infer Children extends readonly ASTNode[]
-  ? {
-      [Idx in keyof Children]: Children[Idx] extends ASTNode
-        ? _Evaluate<Children[Idx], Frame>
-        : never;
-    }
-  : never;
-
-export type Evaluate<Node extends ASTNode> = _Evaluate<Node, EmptyStackFrame>;
-export * from "./common";
-export * from "./eval";
-export * from "./parser";
-export * from "./lexer";
-import { LexerCtx, Token, TokenType } from "./common";
-
-export type IsWhitespace<T extends string> = T extends `${TokenType.SPACE}`
-  ? true
-  : T extends `${TokenType.COMMA}`
-  ? true
-  : T extends `${TokenType.SEMICOLON}`
-  ? true
-  : false;
-
-export type ProcessNameCollection<
-  Ctx extends LexerCtx,
-  Tail extends string,
-  _Token extends Token | null
-> = {
-  next: Tail;
-  nameCollection: "";
-  tokens: _Token extends null
-    ? [
-        ...Ctx["tokens"],
-        ...(Ctx["nameCollection"] extends ""
-          ? []
-          : [Token<TokenType.NAME, Ctx["nameCollection"]>])
-      ]
-    : [
-        ...Ctx["tokens"],
-        ...(Ctx["nameCollection"] extends ""
-          ? [_Token]
-          : [Token<TokenType.NAME, Ctx["nameCollection"]>, _Token])
-      ];
-};
-
-export type IsOpen<T> = T extends `${TokenType.OPEN_PAREN}` ? true : false;
-export type IsClose<T> = T extends `${TokenType.CLOSE_PAREN}` ? true : false;
-
-export type ChunkedLex<
-  Ctx extends LexerCtx,
-  Depth extends any[] = []
-> = Depth["length"] extends 50
-  ? Ctx & {
-      endChunk: true;
-    }
-  : Ctx["next"] extends `${infer Head}${infer Tail}`
-  ? IsWhitespace<Head> extends true
-    ? ChunkedLex<ProcessNameCollection<Ctx, Tail, null>, [0, ...Depth]>
-    : IsOpen<Head> extends true
-    ? ChunkedLex<
-        ProcessNameCollection<Ctx, Tail, Token<TokenType.OPEN_PAREN>>,
-        [0, ...Depth]
-      >
-    : IsClose<Head> extends true
-    ? ChunkedLex<
-        ProcessNameCollection<Ctx, Tail, Token<TokenType.CLOSE_PAREN>>,
-        [0, ...Depth]
-      >
-    : ChunkedLex<
-        {
-          next: Tail;
-          nameCollection: `${Ctx["nameCollection"]}${Head}`;
-          tokens: Ctx["tokens"];
-        },
-        [0, ...Depth]
-      >
-  : Ctx;
-
-export type InnerLex<
-  Next extends string,
-  NameCollection extends LexerCtx["nameCollection"] = "",
-  AccTokens extends Token[] = []
-> = Next extends ""
-  ? AccTokens
-  : ChunkedLex<{
-      next: Next;
-      tokens: [];
-      nameCollection: NameCollection;
-    }> extends infer U
-  ? U extends LexerCtx & { endChunk: true }
-    ? InnerLex<U["next"], U["nameCollection"], [...AccTokens, ...U["tokens"]]>
-    : U extends LexerCtx
-    ? [...AccTokens, ...U["tokens"]]
-    : never
-  : never;
-
-export type Lex<Raw extends string> = InnerLex<`${Raw};`>;
-import { ASTNode, NodeType, ParserCtx, Token, TokenType } from "./common";
-
-export type Error<T extends string> = ASTNode<
-  NodeType.PARSER_ERROR,
-  "Error",
-  T,
-  []
->;
-
-export type PushChild<Node extends ASTNode, Child extends ASTNode> = {
-  type: Node["type"];
-  value: Node["value"];
-  name: Node["name"];
-  children: [...Node["children"], Child];
-};
-
-export type PushChildToLastElementOfStack<
-  Stack extends ParserCtx["stack"],
-  Child extends ASTNode
-> = Stack extends [...infer Head, infer Tail extends ASTNode]
-  ? [...Head, PushChild<Tail, Child>]
-  : Stack extends [infer Only extends ASTNode]
-  ? [PushChild<Only, Child>]
-  : never;
-
-export type PushChildToSecondLastElementOfStack<
-  Stack extends ParserCtx["stack"],
-  Child extends ASTNode
-> = Stack extends [
-  ...infer Head,
-  infer Tail extends ASTNode,
-  infer Final extends ASTNode
-]
-  ? [...Head, PushChild<Tail, Child>, Final]
-  : Stack extends [infer Only extends ASTNode, infer Final extends ASTNode]
-  ? [PushChild<Only, Child>, Final]
-  : never;
-
-export type GetLastOnStack<Stack extends ParserCtx["stack"]> = Stack extends [
-  ...infer Head,
-  infer Tail extends ASTNode
-]
-  ? Tail
-  : Stack extends [infer Only extends ASTNode]
-  ? Only
-  : never;
-
-export type StackWithoutLast<Stack extends ParserCtx["stack"]> = Stack extends [
-  ...infer Head extends ASTNode[],
-  infer Tail
-]
-  ? [...Head]
-  : Stack extends [infer Only extends ASTNode]
-  ? []
-  : never;
-
-type NULL_SENTINEL = {
-  NULL: true;
-};
-
-export type ParseNumberLiteral<T extends string> =
-  T extends `${infer Inner extends number}` ? Inner : NULL_SENTINEL;
-
-export type ParseStringLiteral<T extends string> =
-  T extends `"${infer Inner extends string}"` ? Inner : NULL_SENTINEL;
-
-export type ResolveNodeFromToken<_Token extends Token> = ParseNumberLiteral<
-  _Token["name"]
-> extends number
-  ? ASTNode<NodeType.INT, "", ParseNumberLiteral<_Token["name"]>, []>
-  : ParseStringLiteral<_Token["name"]> extends string
-  ? ASTNode<NodeType.INT, "", ParseStringLiteral<_Token["name"]>, []>
-  : ASTNode<NodeType.EXT, _Token["name"], null, []>;
-
-export type _Parse<Ctx extends ParserCtx> = Ctx["remainingTokens"] extends [
-  infer Head extends Token,
-  ...infer Tail extends readonly Token[]
-]
-  ? Ctx["lastToken"] extends Token
-    ? Head["type"] extends TokenType.NAME
-      ? // we already have a lastToken
-        // mutate last element of stack to push lastToken as child
-        // lastToken = nextToken
-        // goto start
-        _Parse<{
-          lastToken: Head;
-          remainingTokens: Tail;
-          stack: PushChildToLastElementOfStack<
-            Ctx["stack"],
-            ResolveNodeFromToken<Ctx["lastToken"]>
-          >;
-        }>
-      : //nextToken is openParen or close paren
-      Head["type"] extends TokenType.CLOSE_PAREN
-      ? // handle lastToken
-        // set last element of stack as child of prev element on stack
-        // pop stack
-        // [stack[last - 1].children.push(stack.pop)
-        // goto start
-        _Parse<{
-          lastToken: null;
-          remainingTokens: Tail;
-          // first push the last name onto the children of the top
-          // then push the top onto the children of the next
-          // then remove the top
-          stack: StackWithoutLast<
-            PushChildToSecondLastElementOfStack<
-              Ctx["stack"],
-              PushChild<
-                GetLastOnStack<Ctx["stack"]>,
-                ResolveNodeFromToken<Ctx["lastToken"]>
-              >
-            >
-          >;
-        }>
-      : Head["type"] extends TokenType.OPEN_PAREN
-      ? // push lastToken onto stack
-        // goto start
-        _Parse<{
-          lastToken: null;
-          remainingTokens: Tail;
-          stack: [...Ctx["stack"], ResolveNodeFromToken<Ctx["lastToken"]>];
-        }>
-      : Ctx & Error<`Was not expecting ${Head["type"]}`>
-    : // expect nextToken to be a name or close paren
-    Head["type"] extends TokenType.NAME
-    ? // lastToken = nextToken
-      // goto start
-      _Parse<{
-        lastToken: Head;
-        remainingTokens: Tail;
-        stack: Ctx["stack"];
-      }>
-    : Head["type"] extends TokenType.CLOSE_PAREN
-    ? _Parse<{
-        lastToken: null;
-        remainingTokens: Tail;
-        // push the top onto the children of the next
-        // then remove the top
-        stack: StackWithoutLast<
-          PushChildToSecondLastElementOfStack<
-            Ctx["stack"],
-            GetLastOnStack<Ctx["stack"]>
-          >
-        >;
-      }>
-    : Ctx &
-        Error<`Expected nextToken to be a name or close paren at ${Head["type"]}`>
-  : Ctx["lastToken"] extends Token
-  ? // case where we ended with a name
-    _Parse<{
-      lastToken: null;
-      remainingTokens: [];
-      stack: PushChildToLastElementOfStack<
-        Ctx["stack"],
-        ResolveNodeFromToken<Ctx["lastToken"]>
-      >;
-    }>
-  : Ctx["stack"][0];
-
-export type Parse<Raw extends readonly Token[]> = _Parse<{
-  lastToken: null;
-  remainingTokens: Raw;
-  stack: [ASTNode<NodeType.EXT, "arr", null, []>];
-}>;
-export * from "./core";
-export * from "./number";
-export * from "./utils";
-export * from "./string";
-export type NumberToArray<
-  Number extends number,
-  Carry extends readonly any[] = []
-> = Number extends Carry["length"]
-  ? Carry
-  : NumberToArray<Number, [...Carry, any]>;
-
-export type NumbersToArray<
-  Numbers extends readonly number[],
-  Carry extends readonly any[] = []
-> = Numbers extends [
-  infer Head extends number,
-  ...infer Tail extends readonly number[]
-]
-  ? NumbersToArray<Tail, [...Carry, ...NumberToArray<Head>]>
-  : Carry;
-
-export type AddNumbers<Numbers extends readonly number[]> =
-  NumbersToArray<Numbers> extends infer T extends readonly any[]
-    ? T["length"]
-    : never;
-
-export type MultiplyInner<
-  N extends number,
-  MS extends readonly any[],
-  Carry extends number = 0
-> = MS extends [infer Head extends number, ...infer Tail extends readonly any[]]
-  ? MultiplyInner<N, Tail, AddNumbers<[Carry, N]>>
-  : Carry;
-
-export type Multiply<M extends number, N extends number> = MultiplyInner<
-  M,
-  NumberToArray<N>
->;
-
-export type ExtractNumber<T extends any> =
-  T extends `${infer Inner extends number}` ? Inner : never;
-export type AddStrings<
-  Strings extends readonly string[],
-  Carry extends string = ""
-> = Strings extends [infer Head extends string, ...infer Tail extends string[]]
-  ? AddStrings<Tail, `${Carry}${Head}`>
-  : Carry;
-
-export type ToString<T, Carry extends string = ""> = T extends string | number
-  ? `${T}`
-  : T extends readonly any[]
-  ? T extends readonly [infer Head, ...infer Tail]
-    ? `${ToString<
-        Tail,
-        `${Carry extends "" ? "" : `${Carry}, `}${ToString<Head>}`
-      >}`
-    : `[${Carry}]`
-  : never;
-export type UnarrayIfOnlyHead<T extends readonly any[]> = T extends [
-  infer Head,
-  infer Next
-]
-  ? T
-  : T extends [infer Head]
-  ? Head
-  : T;
-import { evaluate, lex, parse } from "./lang";
-import { createFn } from "./lang";
-
-const adder = createFn("fn(x, map(arr(10,20,30), fn(y, add(x, y))))");
-
-const result = adder(5);
-console.log(result);