[{"_1":2,"_171":-5,"_172":-5},"loaderData",{"_3":4,"_92":93},"root",{"_5":6,"_35":36,"_65":66},"ctx",{"_7":8,"_23":-5,"_24":25,"_26":27,"_28":20,"_29":20,"_30":20,"_31":32,"_33":20,"_34":20},"auth",{"_9":-5,"_10":-5,"_11":-5,"_12":-5,"_13":-5,"_14":-5,"_15":-5,"_16":-5,"_17":-5,"_18":-5,"_19":20,"_21":22},"sessionClaims","sessionId","sessionStatus","userId","actor","orgId","orgRole","orgSlug","orgPermissions","factorVerificationAge","isAuthenticated",false,"tokenType","session_token","user","preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","notificationCount",0,"flagDenols","isTeamOrgMember","ENV",{"_37":38,"_39":40,"_41":42,"_43":44,"_45":46,"_47":48,"_49":50,"_51":52,"_53":54,"_55":56,"_57":58,"_59":60,"_61":62,"_63":64},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","VAL_RUNTIME_NAME","prod","RENDER_GIT_COMMIT","5c349ef9e7d7333839a0634dd567aae2d49623a6","RENDER_GIT_BRANCH","main","CLERK_PUBLISHABLE_KEY","pk_live_Y2xlcmsudmFsLnRvd24k","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","API_URL","https://api.val.town","clerkState",{"_67":68},"__internal_clerk_state",{"_69":70,"_71":46,"_72":73,"_74":73,"_75":20,"_76":73,"_77":73,"_78":73,"_79":73,"_80":81,"_90":20,"_91":20},"__clerk_ssr_state",{"_21":22,"_9":-5,"_10":-5,"_11":-5,"_12":-5,"_13":-5,"_14":-5,"_15":-5,"_16":-5,"_17":-5,"_18":-5,"_19":20},"__publishableKey","__proxyUrl","","__domain","__isSatellite","__signInUrl","__signUpUrl","__afterSignInUrl","__afterSignUpUrl","__clerk_debug",{"_82":20,"_19":20,"_83":73,"_84":85,"_86":73,"_87":46,"_88":20,"_89":73},"isSignedIn","proxyUrl","reason","session-token-and-uat-missing","message","publishableKey","isSatellite","domain","__telemetryDisabled","__telemetryDebug","routes/embed.x.$handle.$name.$",{"_94":95,"_96":97,"_98":99,"_100":101,"_150":151,"_168":169,"_170":-5},"handle","zackoverflow","name","lisp","path","main.tsx","project",{"_102":103,"_96":97,"_104":105,"_106":-5,"_107":20,"_108":109,"_110":-5,"_111":-5,"_12":112,"_113":-5,"_114":115,"_116":-5,"_117":-5,"_118":119,"_14":120,"_121":122,"_123":122,"_124":125,"_126":125,"_127":125,"_128":122,"_129":122,"_23":130,"_133":134,"_136":137,"_149":20},"id","7a07304e-2778-11f0-b46e-569c3dd06744","createdAt",["D",1746205884531],"deletedAt","legacyEnvVars","privacy","public","description","imageUrl","77510391-82b8-49b5-834f-c5635e9a5906","pinnedFileId","pinPreview",true,"pinMigrated","screenshotVersion","likeCount",2,"29b476a3-03ae-411b-a217-c0b4be170058","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm",{"_94":95,"_131":132},"profileImageUrl","https://images.clerk.dev/uploaded/img_2Tg3AwqUy52inqmZfg4MbeC7G09.webp","org",{"_94":95,"_135":132,"_12":112},"avatar","branch",{"_138":139,"_96":44,"_102":140,"_141":103,"_142":-5,"_143":-5,"_144":-5,"_145":-5,"_146":-5,"_147":97,"_148":95},"version",98,"7a078454-2778-11f0-b46e-569c3dd06744","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","isOwned","file",{"_102":152,"_96":99,"_153":154,"_155":-5,"_156":140,"_157":139,"_158":115,"_104":159,"_138":160,"_161":162,"_163":164,"_165":20,"_166":-5,"_98":167},"7cdeca98-2778-11f0-b46e-569c3dd06744","fileId","7a0ac0a6-2778-11f0-b46e-569c3dd06744","parentId","branchId","branchVersion","latest",["D",1698082309000],97,"fileType","script","content","export const lisp = (src: string, onlyParse: boolean = false) => {\n type LispValue = {\n type: \"null\";\n value: null;\n } | {\n type: \"str\";\n value: string;\n } | {\n type: \"num\";\n value: number;\n } | {\n type: \"sym\";\n value: string;\n } | {\n type: \"symp\";\n value: string;\n } | {\n type: \"lambda\";\n value: Lambda;\n } | {\n type: \"builtin\";\n value: string;\n } | {\n type: \"plist\";\n value: Plist;\n } | {\n type: \"list\";\n value: Array;\n };\n type List = Array;\n type Plist = Record;\n type Lambda = {\n containsSpreadArg: boolean;\n args: string[];\n code: AstExpr;\n };\n type AstExpr =\n | {\n type: \"str\";\n value: [\n string,\n ];\n }\n | {\n type: \"num\";\n value: [\n number,\n ];\n }\n | App\n | {\n type: \"sym\";\n value: [\n string,\n ];\n }\n | {\n type: \"symp\";\n value: [\n string,\n ];\n };\n type App = {\n type: \"app\";\n value: Array;\n };\n const makeStr = (value: string): AstExpr => ({\n type: \"str\",\n value: [value],\n });\n const makeNum = (value: number): AstExpr => ({\n type: \"num\",\n value: [value],\n });\n const makeSymp = (value: string): AstExpr => ({\n type: \"symp\",\n value: [value],\n });\n const makeSym = (value: string): AstExpr => {\n return {\n type: \"sym\",\n value: [value],\n };\n };\n const makeApply = (value: Array): AstExpr => ({\n type: \"app\",\n value,\n });\n const parse = (src: string): Array => {\n let idx = 0;\n const peek = (): string | undefined =>\n idx >= src.length ? undefined : src[idx];\n const matchEat = (expected: string): boolean | undefined => {\n const char = peek();\n if (char === undefined)\n return undefined;\n const match = char === expected;\n if (match) {\n idx += 1;\n }\n return match;\n };\n const AstExprs: Array = [];\n function parseAstExpr(): AstExpr | undefined {\n eatWhitspace();\n const p = peek();\n if (!p)\n return undefined;\n switch (p) {\n case \"(\": {\n idx += 1;\n return parseApply();\n }\n default: {\n const num = parseNumber(p);\n if (num !== undefined) {\n return makeNum(num);\n }\n const str = parseString(p);\n if (str !== undefined)\n return makeStr(str);\n const sym = parseSym(p);\n if (sym !== undefined) {\n if (sym[0] === \":\" || sym[0] === \"'\") {\n const actualSym = sym.slice(1);\n if (actualSym.length === 0)\n throw new Error(\"Invalid empty symbol\");\n return makeSymp(actualSym);\n }\n return makeSym(sym);\n }\n throw new Error(\"Bad value\");\n }\n }\n }\n function parseApply(): AstExpr | undefined {\n const args: Array = [];\n while (true) {\n eatWhitspace();\n const matches = matchEat(\")\");\n if (matches === undefined)\n throw new Error(\"parseApply: Unexpected eof\");\n if (matches)\n break;\n const expr = parseAstExpr();\n if (expr === undefined)\n return undefined;\n args.push(expr);\n }\n return makeApply(args);\n }\n function parseSym(char: string): string | undefined {\n let sym = char;\n idx += 1;\n while (true) {\n const p = peek();\n if (p === undefined)\n throw new Error(\"parseSym: Unexpected EOF\");\n if (isWhitespace(p) || p === \")\" || p === \"(\") {\n return sym;\n }\n sym += p;\n idx++;\n }\n }\n function parseString(char: string): string | undefined {\n if (char !== '\"')\n return undefined;\n const quotType = char;\n idx += 1;\n let theString = \"\";\n while (idx <= src.length) {\n const matches = matchEat(quotType);\n if (!matchEat)\n throw new Error(\"parseString: Unexpected eof\");\n if (matches)\n break;\n theString += src[idx++];\n }\n return theString;\n }\n function parseNumber(char: string): number | undefined {\n const start = 48;\n const startNoZero = 49;\n const end = 57;\n let charCode = char.charCodeAt(0);\n // is zero\n if (charCode === start) {\n if (\n src[idx + 1] === undefined ||\n !(charCode >= startNoZero && charCode <= end)\n ) {\n idx++;\n return 0;\n }\n }\n if (charCode >= startNoZero && charCode <= end) {\n let numValue = 0;\n while (true) {\n const p = peek();\n if (p === undefined)\n throw new Error(\"parseNumber: Unexpected EOF\");\n charCode = p.charCodeAt(0);\n if (charCode >= start && charCode <= end) {\n numValue *= 10;\n numValue += parseInt(p);\n idx += 1;\n }\n else {\n return numValue;\n }\n }\n }\n return undefined;\n }\n function eatWhitspace() {\n while (true) {\n const p = peek();\n if (p === undefined)\n return;\n if (!isWhitespace(p))\n return;\n idx++;\n }\n }\n function isWhitespace(char: string): boolean {\n return char === \" \" || char === \"\\n\" || char === \"\\r\" || char === \"\\t\";\n }\n // Main parse loop\n while (idx < src.length) {\n const AstExpr = parseAstExpr();\n if (!AstExpr)\n break;\n AstExprs.push(AstExpr);\n }\n return AstExprs;\n };\n const run = (exprs: Array) => {\n const makeValStr = (str: string): LispValue => ({\n value: str,\n type: \"str\",\n });\n const makeValNum = (num: number): LispValue => ({\n value: num,\n type: \"num\",\n });\n const makeValSym = (sym: string): LispValue => ({\n value: sym,\n type: \"sym\",\n });\n const makeValSymp = (sym: string): LispValue => ({\n value: sym,\n type: \"symp\",\n });\n const makeValNull = (): LispValue => ({ type: \"null\", value: null });\n const makeValLambda = (\n args: string[],\n containsSpreadArg: boolean,\n code: AstExpr,\n ): LispValue => ({\n value: { args, code, containsSpreadArg },\n type: \"lambda\",\n });\n const makeValBuiltin = (name: string): LispValue => ({\n value: name,\n type: \"builtin\",\n });\n const makeValPlist = (values: Record): LispValue => ({\n value: values,\n type: \"plist\",\n });\n const makeValArray = (values: Array): LispValue => ({\n value: values,\n type: \"list\",\n });\n type Env = Record;\n const initialEnv = (): [\n env: Env,\n argMap: Record,\n ] => {\n const env: Env = {};\n const builtinArgMap: Record = {};\n const builtins: Array<[\n op: string,\n args: number,\n hasRest?: boolean,\n ]> = [\n [\"-\", 2, false],\n [\"+\", 2],\n [\"*\", 2],\n [\"/\", 2],\n [\"print\", 0, true],\n [\"setq\", 2],\n [\"defun\", 2],\n [\"let\", 2],\n [\"if\", 3],\n [\"<=\", 2],\n [\"=\", 2],\n [\"assert-eq\", 2],\n [\"plist\", 1, true],\n [\"set\", 2, true],\n [\"get\", 2],\n [\"list\", 1, true],\n [\"list-get\", 2],\n [\"length\", 1],\n [\"append\", 1, true],\n [\"apply\", 2],\n ];\n builtins.forEach(([op, args, hasRest]) => {\n env[op] = makeValBuiltin(op);\n Object.assign(builtinArgMap, {\n [op]: { args, hasRest: hasRest === undefined ? false : hasRest },\n });\n });\n env[\"true\"] = makeValNum(1);\n env[\"false\"] = makeValNum(0);\n env[\"null\"] = makeValSym(\"null\");\n return [env, builtinArgMap];\n };\n const valToString = (val: LispValue): string => {\n switch (val.type) {\n case \"list\": {\n return JSON.stringify(val.value.map((value) => valToString(value)));\n }\n case \"plist\": {\n return JSON.stringify(\n Object.keys(val.value).reduce(\n (acc, cur) => ({ ...acc, [cur]: valToString(val.value[cur]) }),\n {},\n ),\n );\n }\n case \"str\":\n case \"num\":\n case \"sym\":\n return String(val.value);\n case \"symp\":\n return \"'\" + val.value;\n case \"lambda\":\n return `lambda unknown`;\n case \"builtin\":\n return \"builtin\";\n case \"null\":\n return \"null\";\n }\n };\n const cloneEnv = (env: Env) => ({ ...env });\n const envGet = (env: Env, key: string): LispValue => {\n const value = env[key];\n if (!value)\n throw new Error(`Undefined variable ${key}`);\n return value;\n };\n const envGetSymp = (env: Env, symp: string): LispValue => envGet(env, symp);\n const envSetFromExpr = (env: Env, key: LispValue, value: LispValue) => {\n if (key.type !== \"str\")\n throw new Error(`Expected lisp string got: ${key.type}`);\n env[key.value] = value;\n };\n const isEqual = (a: LispValue, b: LispValue): boolean => {\n if (a.type !== b.type)\n return false;\n switch (a.type) {\n case \"list\": {\n if (b.type !== \"list\")\n return false;\n if (b.value.length !== a.value.length)\n return false;\n for (let i = 0; i < a.value.length; i++) {\n if (!isEqual(a.value[i], b.value[i]))\n return false;\n }\n return true;\n }\n case \"plist\": {\n if (b.type != \"plist\")\n return false;\n if (Object.keys(a.value).length !== Object.keys(b.value).length)\n return false;\n for (const key of Object.keys(a.value)) {\n const exists = key in b.value;\n if (!exists)\n return false;\n const aval = a.value[key];\n const bval = b.value[key];\n if (!isEqual(aval, bval))\n return false;\n }\n return true;\n }\n case \"num\":\n case \"str\":\n case \"sym\":\n case \"symp\":\n return a.value === b.value;\n case \"lambda\":\n case \"builtin\":\n return false;\n case \"null\":\n return true;\n }\n };\n const isTruthy = (env: Env, val: LispValue): boolean => {\n switch (val.type) {\n case \"num\": {\n return val.value !== 0;\n }\n case \"list\":\n case \"plist\":\n case \"str\":\n case \"builtin\":\n return true;\n case \"sym\":\n const symbol = envGet(env, val.value);\n return isTruthy(env, symbol);\n case \"lambda\":\n // All lambdas are truthy\n return true;\n default:\n return false;\n }\n };\n const isValidPlist = (potentialPlist: LispValue): Plist => {\n if (potentialPlist.type === \"null\")\n return {};\n if (potentialPlist.type === \"plist\")\n return potentialPlist.value;\n throw new Error(\"Not a plist\");\n };\n function evaluate(env: Env, expr: AstExpr): LispValue {\n switch (expr.type) {\n case \"str\": {\n return makeValStr(expr.value[0]);\n }\n case \"app\": {\n return evaluateApp(env, expr);\n }\n case \"num\": {\n return makeValNum(expr.value[0]);\n }\n case \"symp\": {\n return makeValSymp(expr.value[0]);\n }\n case \"sym\": {\n if (expr.value[0] === \"null\")\n return makeValNull();\n return envGet(env, expr.value[0]);\n }\n }\n }\n function evaluateLambdaWithValues(lambdaEnv: Env, fn: {\n type: \"lambda\";\n value: Lambda;\n }, argVals: LispValue[]) {\n const containsSpread = fn.value.containsSpreadArg;\n if (\n containsSpread\n ? argVals.length < fn.value.args.length\n : argVals.length !== fn.value.args.length\n ) {\n throw new Error(\n `Wrong number of args. Expected ${fn.value.args.length} but got ${argVals.length}`,\n );\n }\n const last = fn.value.args.length === 0 ? 0 : fn.value.args.length - 1;\n const spreadArgs = containsSpread ? argVals.slice(last) : undefined;\n fn.value.args.forEach((arg, idx) => {\n if (containsSpread && idx >= last) {\n const val = argVals[idx];\n lambdaEnv[arg] = val;\n }\n });\n const result = evaluate(lambdaEnv, fn.value.code);\n return result;\n }\n function lispValToExpr(val: LispValue): AstExpr {\n switch (val.type) {\n case \"str\":\n return { type: \"str\", value: [val.value] };\n case \"num\":\n return { type: \"num\", value: [val.value] };\n case \"sym\":\n return { type: \"sym\", value: [val.value] };\n case \"symp\":\n return { type: \"symp\", value: [val.value] };\n case \"list\":\n return { type: \"app\", value: val.value.map(lispValToExpr) };\n default:\n throw new Error(`Unsupported LispValue type: ${val.type}`);\n }\n }\n function evaluateBuiltin(\n env: Env,\n builtin: string,\n args: Array,\n ): LispValue {\n switch (builtin) {\n case \"append\": {\n const [listExpr, ...restExpr] = args;\n const list = evaluate(env, listExpr);\n if (!(list.type === \"list\" || list.type === \"null\"))\n throw new Error(\"First arg of `append` should be a list or null\");\n const actualList = list.type === \"null\" ? [] : list.value;\n const appendValues = restExpr.map((expr) => evaluate(env, expr));\n return makeValArray([...actualList, ...appendValues]);\n }\n case \"apply\": {\n const [fnExpr, ...argsExpr] = args;\n const fnSymp = evaluate(env, fnExpr);\n if (fnSymp.type !== \"symp\")\n throw new Error(\"Apply first arg should be symp\");\n if (argsExpr.length > 1)\n throw new Error(\"Apply requires 2 arguments\");\n const argsVal = evaluate(env, argsExpr[0]);\n if (argsVal.type !== \"list\")\n throw new Error(\"Apply second arg should be a list\");\n const fn = envGetSymp(env, fnSymp.value);\n if (fn.type === \"builtin\") {\n return evaluateBuiltin(\n env,\n fn.value,\n argsVal.value.map((val) => lispValToExpr(val)),\n );\n }\n if (fn.type !== \"lambda\")\n throw new Error(\"First arg to `apply` must be a lambda\");\n const lambdaEnv = addArgsToEnv(env, fn, argsExpr);\n return evaluate(lambdaEnv, fn.value.code);\n }\n case \"length\": {\n const [valExpr] = args;\n const val = evaluate(env, valExpr);\n switch (val.type) {\n case \"str\":\n return makeValNum(val.value.length);\n case \"plist\":\n return makeValNum(Object.keys(val.value).length);\n case \"list\":\n return makeValNum(val.value.length);\n default: {\n throw new Error(\"Length arg is not str, plist, or list\");\n }\n }\n }\n case \"plist\": {\n const keyVals = args;\n let plist: Plist = {};\n for (let i = 0; i < keyVals.length; i += 2) {\n const keyExpr = keyVals[i];\n const valExpr = keyVals[i + 1];\n let keyLispVal = evaluate(env, keyExpr);\n if (keyLispVal.type === \"symp\") {\n keyLispVal = makeValStr(keyLispVal.value);\n }\n if (keyLispVal.type !== \"str\") {\n throw new Error(\n `Plist key must be a symp or str, got: ${\n valToString(keyLispVal)\n }`,\n );\n }\n const val = evaluate(env, valExpr);\n plist[keyLispVal.value] = val;\n }\n return makeValPlist(plist);\n }\n case \"get\": {\n const [maybePlist, keyExpr] = args;\n const plist = isValidPlist(evaluate(env, maybePlist));\n const key = evaluate(env, keyExpr);\n if (key.type !== \"str\" || key.value !== \"symp\")\n throw new Error(\"Key in `get` should be a symp or str\");\n return plist[key.value] || makeValNull();\n }\n case \"set\": {\n const [potentialPlist, ...keyVals] = args;\n let plist = { ...isValidPlist(evaluate(env, potentialPlist)) };\n if (keyVals.length === 0 || keyVals.length % 2 !== 0)\n throw new Error(\"Set requires valid key val pair\");\n for (let i = 0; i < keyVals.length; i += 2) {\n const keyExpr = keyVals[i];\n const valExpr = keyVals[i + 1];\n let keyLispVal = evaluate(env, keyExpr);\n if (keyLispVal.type === \"symp\") {\n keyLispVal = makeValStr(keyLispVal.value);\n }\n if (keyLispVal.type !== \"str\") {\n throw new Error(\n `Plist key must be a symp or str, got: ${\n valToString(keyLispVal)\n }`,\n );\n }\n const val = evaluate(env, valExpr);\n plist[keyLispVal.value] = val;\n }\n return makeValPlist(plist);\n }\n case \"list-get\": {\n const [listExpr, idxExpr] = args;\n const list = evaluate(env, listExpr);\n if (list.type !== \"list\")\n throw new Error(\"First arg in `list-get` is not a list\");\n const idx = evaluate(env, idxExpr);\n if (idx.type !== \"num\")\n throw new Error(\"Second arg in `list-get` is not a number\");\n return list.value[Math.floor(idx.value)] || makeValNull();\n }\n case \"list\": {\n // (list a b c d)\n if (args.length === 0)\n throw new Error(\"`list` expects at least 1 arg\");\n const values: Array = [];\n for (const arg of args) {\n values.push(evaluate(env, arg));\n }\n return makeValArray(values);\n }\n case \"defun\": {\n // (defun foo (a b) (+ a b))\n const [fnNameExpr, fnArgs, body] = args;\n if (fnNameExpr === undefined)\n throw new Error(\"No fn name\");\n if (fnNameExpr.type !== \"sym\")\n throw new Error(\n `Fn name should be a symbol not a ${fnNameExpr.type}`,\n );\n if (fnArgs === undefined)\n throw new Error(\"No fn args\");\n if (body === undefined)\n throw new Error(\"no function body\");\n if (fnArgs.type !== \"app\")\n throw new Error(\"Fn args expected list\");\n const last = fnArgs.value.length === 0 ? 0 : fnArgs.value.length - 1;\n let containsSpreadArg = false;\n const fnName = makeValStr(fnNameExpr.value[0]);\n envSetFromExpr(\n env,\n fnName,\n makeValLambda(\n [\n ...fnArgs.value.map((f: AstExpr, i) => {\n if (f.type !== \"sym\")\n throw new Error(\"arg must be sym\");\n const isSpread = f.value[0].indexOf(\"...\") === 0;\n if (isSpread && i !== last)\n throw new Error(\"Spread arg must be last arg\");\n if (isSpread && f.value[0].length === 3)\n throw new Error(\"`...` is invalid for a spread arg\");\n if (isSpread) {\n containsSpreadArg = true;\n return f.value[0].slice(3);\n }\n return f.value[0];\n }),\n ],\n containsSpreadArg,\n body,\n ),\n );\n return makeValNull();\n }\n case \"+\": {\n const sum = args\n .map((arg) => evaluate(cloneEnv(env), arg))\n .reduce((acc, cur) => {\n if (cur.type !== \"num\")\n throw new Error(\"Expected num\");\n return acc + cur.value;\n }, 0);\n return makeValNum(sum);\n }\n case \"let\": {\n const [bindings, body] = args;\n if (\n !bindings ||\n bindings.type !== \"app\" ||\n bindings.value.length === 0\n )\n throw new Error(\"No bindings!\");\n if (!body)\n throw new Error(\"No body!\");\n const newEnv = cloneEnv(env);\n bindings.value.forEach((binding) => {\n if (binding.type !== \"app\")\n throw new Error(\"Invalid binding\");\n const [name, valueExpr] = binding.value;\n if (name === undefined || valueExpr === undefined)\n throw new Error(\"Binding expected a name and a value expr\");\n if (name.type !== \"sym\")\n throw new Error(\"Binding name just be a symbol\");\n const value = evaluate(cloneEnv(newEnv), valueExpr);\n envSetFromExpr(newEnv, makeValStr(name.value[0]), value);\n });\n return evaluate(newEnv, body);\n }\n case \"if\": {\n const [cond, then, ...elze] = args;\n if (cond === undefined || then === undefined || elze === undefined)\n throw new Error(\"Bad if\");\n const condVal = evaluate(env, cond);\n if (isTruthy(env, condVal)) {\n return evaluate(env, then);\n }\n else {\n const tempEnv = env;\n let result = makeValNull();\n for (const expr of elze) {\n result = evaluate(tempEnv, expr);\n }\n return result;\n }\n }\n case \"print\": {\n const valueStrings = args\n .map((arg) => evaluate(env, arg))\n .map(valToString);\n console.log(valueStrings.join(\" \"));\n return makeValNull();\n }\n case \"=\": {\n const [a, b] = args;\n if (a === undefined || b === undefined)\n throw new Error('Bad \"=\"');\n const [aval, bval] = args.map((arg) => evaluate(env, arg));\n if (aval === undefined || bval === undefined)\n throw new Error('Bad \"=\"');\n return isEqual(aval, bval) ? makeValNum(1) : makeValNum(0);\n }\n case \"<=\": {\n const [a, b] = args;\n if (a === undefined || b === undefined)\n throw new Error('Bad \"<=\"');\n const [aval, bval] = args.map((arg) => evaluate(env, arg));\n if (aval?.type !== \"num\" || bval?.type !== \"num\")\n throw new Error('Bad \"<=\"');\n return aval.value <= bval.value ? makeValNum(1) : makeValNum(0);\n }\n case \"assert-eq\": {\n const [a, b] = args;\n if (a === undefined || b === undefined)\n throw new Error('Bad \"=\"');\n const [aval, bval] = args.map((arg) => evaluate(env, arg));\n if (aval === undefined || bval === undefined)\n throw new Error('Bad \"=\"');\n if (isEqual(aval, bval))\n return makeValNum(1);\n throw new Error(\n `Assertion failed: ${valToString(aval)} != ${valToString(bval)}`,\n );\n }\n default: {\n throw new Error(`Unhandled builtin: ${builtin}`);\n }\n }\n }\n function addArgsToEnv(env: Env, fn: {\n type: \"lambda\";\n value: Lambda;\n }, args: AstExpr[]): Env {\n const containsSpread: boolean = fn.value.containsSpreadArg;\n const last: number = fn.value.args.length === 0\n ? 0\n : fn.value.args.length - 1;\n const argEnv = cloneEnv(env);\n const spreadArgs = containsSpread\n ? args.slice(last).map((arg) => evaluate(env, arg))\n : undefined;\n let lambdaEnv = cloneEnv(env);\n fn.value.args.forEach((arg, idx) => {\n if (containsSpread && idx >= last) {\n lambdaEnv[arg] = makeValArray(spreadArgs!);\n }\n else {\n const val = evaluate(argEnv, args[idx]!);\n lambdaEnv[arg] = val;\n }\n });\n return lambdaEnv;\n }\n function evaluateApp(env: Env, app: App): LispValue {\n const [fnExpr, ...args] = app.value;\n if (fnExpr === undefined)\n throw new Error(\"No fn expr\");\n const fn = evaluate(env, fnExpr);\n if (fn.type === \"builtin\")\n return evaluateBuiltin(env, fn.value, args);\n if (fn.type === \"lambda\") {\n const lambdaEnv = addArgsToEnv(env, fn, args);\n return evaluate(lambdaEnv, fn.value.code);\n }\n throw new Error(`Invalid function value: ${fn.type}`);\n }\n const [__ENV, argMap] = initialEnv();\n let ENV = __ENV;\n let result: LispValue | undefined = undefined;\n for (const expr of exprs) {\n const tempEnv = cloneEnv(ENV);\n result = evaluate(tempEnv, expr);\n ENV = tempEnv;\n }\n return result;\n };\n const values = parse(src);\n if (onlyParse)\n return values;\n return run(values);\n};","deleted","label",[99],"permalink","https://www.val.town/x/zackoverflow/lisp/code/main.tsx","extension","actionData","errors"]