@lionlang/core 0.1.1 → 0.2.0

package/README.md

@@ -2,6 +2,8 @@
 
 Lion is a JSON-based Lisp. Every Lion program is valid JSON, which makes it easy to serialize, store, inspect, and generate from other systems.
 
+The evaluator runs on Effect v4.
+
 Lion evaluates:
 
 - JSON primitives directly

package/dist/analysis/analyze.d.mts

@@ -0,0 +1,34 @@
+import { a as LionExpressionType } from "../lion-expression-DMR7Psmu.mjs";
+
+//#region src/analysis/analyze.d.ts
+type StructuralPath = readonly (number | string)[];
+type SemanticKind = "primitive" | "record" | "array" | "empty-array" | "call" | "special-form" | "invalid-call";
+type SpecialFormName = "begin" | "cond" | "define" | "eval" | "lambda" | "match" | "quote";
+interface SemanticRelationship {
+  readonly kind: "definition" | "reference-candidate";
+  readonly name: string;
+}
+interface SemanticChild {
+  readonly node: SemanticNode;
+  readonly order: number;
+  readonly role: string;
+}
+interface SemanticNode {
+  readonly children: readonly SemanticChild[];
+  readonly diagnostic?: string;
+  readonly kind: SemanticKind;
+  readonly label: string;
+  readonly path: StructuralPath;
+  readonly pointer: string;
+  readonly quoted: boolean;
+  readonly relationships: readonly SemanticRelationship[];
+  readonly specialForm?: SpecialFormName;
+  readonly value?: boolean | null | number | string;
+}
+declare const pathToPointer: (path: StructuralPath) => string;
+declare const isSpecialFormName: (value: unknown) => value is SpecialFormName;
+declare const analyze: (expression: LionExpressionType) => SemanticNode;
+declare const flattenAnalysis: (root: SemanticNode) => readonly SemanticNode[];
+//#endregion
+export { SemanticChild, SemanticKind, SemanticNode, SemanticRelationship, SpecialFormName, StructuralPath, analyze, flattenAnalysis, isSpecialFormName, pathToPointer };
+//# sourceMappingURL=analyze.d.mts.map

package/dist/analysis/analyze.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.mts","names":[],"sources":["../../src/analysis/analyze.ts"],"mappings":";;;KAYY,cAAA;AAAA,KAEA,YAAA;AAAA,KASA,eAAA;AAAA,UASK,oBAAA;EAAA,SACN,IAAA;EAAA,SACA,IAAA;AAAA;AAAA,UAGM,aAAA;EAAA,SACN,IAAA,EAAM,YAAA;EAAA,SACN,KAAA;EAAA,SACA,IAAA;AAAA;AAAA,UAGM,YAAA;EAAA,SACN,QAAA,WAAmB,aAAA;EAAA,SACnB,UAAA;EAAA,SACA,IAAA,EAAM,YAAA;EAAA,SACN,KAAA;EAAA,SACA,IAAA,EAAM,cAAA;EAAA,SACN,OAAA;EAAA,SACA,MAAA;EAAA,SACA,aAAA,WAAwB,oBAAA;EAAA,SACxB,WAAA,GAAc,eAAA;EAAA,SACd,KAAA;AAAA;AAAA,cAwEE,aAAA,GAAiB,IAAA,EAAM,cAAA;AAAA,cA4IvB,iBAAA,GAAqB,KAAA,cAAiB,KAAA,IAAS,eAAA;AAAA,cAI/C,OAAA,GAAW,UAAA,EAAY,kBAAA,KAAqB,YAAA;AAAA,cAG5C,eAAA,GACX,IAAA,EAAM,YAAA,cACI,YAAA"}

package/dist/analysis/analyze.mjs

@@ -0,0 +1,181 @@
+import { BeginFormSchema, CondFormSchema, DefineFormSchema, EvalFormSchema, LambdaFormSchema, MatchFormSchema, QuoteFormSchema } from "../schemas/evaluation.mjs";
+import { Schema } from "effect";
+//#region src/analysis/analyze.ts
+const roleByIndex = (roles, fallback) => (index) => roles[index] ?? fallback;
+const SPECIAL_FORMS = [
+	{
+		name: "eval",
+		matches: Schema.is(EvalFormSchema),
+		role: roleByIndex(["operator", "expression"], "argument")
+	},
+	{
+		name: "quote",
+		matches: Schema.is(QuoteFormSchema),
+		role: roleByIndex(["operator", "quoted-value"], "quoted-value")
+	},
+	{
+		name: "begin",
+		matches: Schema.is(BeginFormSchema),
+		role: roleByIndex(["operator"], "sequence-item")
+	},
+	{
+		name: "define",
+		matches: Schema.is(DefineFormSchema),
+		role: roleByIndex([
+			"operator",
+			"binding",
+			"value"
+		], "value")
+	},
+	{
+		name: "lambda",
+		matches: Schema.is(LambdaFormSchema),
+		role: roleByIndex([
+			"operator",
+			"parameters",
+			"body"
+		], "body")
+	},
+	{
+		name: "cond",
+		matches: Schema.is(CondFormSchema),
+		role: roleByIndex(["operator"], "branch")
+	},
+	{
+		name: "match",
+		matches: Schema.is(MatchFormSchema),
+		role: (index, length) => {
+			if (index === 0) return "operator";
+			if (index === 1) return "subject";
+			return index === length - 1 ? "fallback" : "pattern";
+		}
+	}
+];
+const SPECIAL_FORM_NAMES = {
+	begin: true,
+	cond: true,
+	define: true,
+	eval: true,
+	lambda: true,
+	match: true,
+	quote: true
+};
+const escapePointerSegment = (segment) => String(segment).replaceAll("~", "~0").replaceAll("/", "~1");
+const pathToPointer = (path) => path.length === 0 ? "" : `/${path.map(escapePointerSegment).join("/")}`;
+const primitiveLabel = (value) => {
+	if (typeof value === "string") return JSON.stringify(value);
+	return String(value);
+};
+const analyzeNode = (expression, path, quoted) => {
+	if (!Array.isArray(expression) && (expression === null || typeof expression !== "object")) {
+		const relationships = [];
+		if (typeof expression === "string") relationships.push({
+			kind: "reference-candidate",
+			name: expression
+		});
+		return {
+			path,
+			pointer: pathToPointer(path),
+			kind: "primitive",
+			label: primitiveLabel(expression),
+			value: expression,
+			quoted,
+			children: [],
+			relationships
+		};
+	}
+	if (!Array.isArray(expression)) {
+		const entries = Object.entries(expression);
+		return {
+			path,
+			pointer: pathToPointer(path),
+			kind: "record",
+			label: entries.length === 0 ? "empty record" : `record · ${entries.length}`,
+			quoted,
+			children: entries.map(([key, value], order) => ({
+				role: key,
+				order,
+				node: analyzeNode(value, [...path, key], quoted)
+			})),
+			relationships: []
+		};
+	}
+	if (expression.length === 0) return {
+		path,
+		pointer: pathToPointer(path),
+		kind: "empty-array",
+		label: "empty array",
+		quoted,
+		children: [],
+		relationships: []
+	};
+	const head = expression[0];
+	const namedForm = SPECIAL_FORMS.find(({ name }) => name === head);
+	const validForm = SPECIAL_FORMS.find(({ matches }) => matches(expression));
+	const relationships = [];
+	if (!quoted && validForm?.name === "define" && typeof expression[1] === "string") relationships.push({
+		kind: "definition",
+		name: expression[1]
+	});
+	const role = quoted ? () => "item" : validForm?.role ?? roleByIndex(["callee"], "argument");
+	const children = expression.map((value, order) => ({
+		role: role(order, expression.length),
+		order,
+		node: analyzeNode(value, [...path, order], quoted || validForm?.name === "quote" && order > 0)
+	}));
+	if (quoted) return {
+		path,
+		pointer: pathToPointer(path),
+		kind: "array",
+		label: `array · ${expression.length}`,
+		quoted,
+		children,
+		relationships
+	};
+	if (!quoted && namedForm && !validForm) return {
+		path,
+		pointer: pathToPointer(path),
+		kind: "invalid-call",
+		label: `invalid ${namedForm.name}`,
+		specialForm: namedForm.name,
+		quoted,
+		children,
+		relationships,
+		diagnostic: `The ${namedForm.name} form has an invalid structure.`
+	};
+	if (!quoted && validForm) return {
+		path,
+		pointer: pathToPointer(path),
+		kind: "special-form",
+		label: validForm.name,
+		specialForm: validForm.name,
+		quoted,
+		children,
+		relationships
+	};
+	const label = typeof head === "string" ? head : "call";
+	return {
+		path,
+		pointer: pathToPointer(path),
+		kind: "call",
+		label,
+		quoted,
+		children,
+		relationships
+	};
+};
+const isSpecialFormName = (value) => typeof value === "string" && Object.hasOwn(SPECIAL_FORM_NAMES, value);
+const analyze = (expression) => analyzeNode(expression, [], false);
+const flattenAnalysis = (root) => {
+	const nodes = [];
+	const visit = (node) => {
+		nodes.push(node);
+		for (const child of node.children) visit(child.node);
+	};
+	visit(root);
+	return nodes;
+};
+//#endregion
+export { analyze, flattenAnalysis, isSpecialFormName, pathToPointer };
+
+//# sourceMappingURL=analyze.mjs.map

package/dist/analysis/analyze.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.mjs","names":[],"sources":["../../src/analysis/analyze.ts"],"sourcesContent":["import { Schema } from \"effect\";\nimport {\n  BeginFormSchema,\n  CondFormSchema,\n  DefineFormSchema,\n  EvalFormSchema,\n  LambdaFormSchema,\n  MatchFormSchema,\n  QuoteFormSchema,\n} from \"@/schemas/evaluation\";\nimport type { LionExpressionType } from \"@/schemas/lion-expression\";\n\nexport type StructuralPath = readonly (number | string)[];\n\nexport type SemanticKind =\n  | \"primitive\"\n  | \"record\"\n  | \"array\"\n  | \"empty-array\"\n  | \"call\"\n  | \"special-form\"\n  | \"invalid-call\";\n\nexport type SpecialFormName =\n  | \"begin\"\n  | \"cond\"\n  | \"define\"\n  | \"eval\"\n  | \"lambda\"\n  | \"match\"\n  | \"quote\";\n\nexport interface SemanticRelationship {\n  readonly kind: \"definition\" | \"reference-candidate\";\n  readonly name: string;\n}\n\nexport interface SemanticChild {\n  readonly node: SemanticNode;\n  readonly order: number;\n  readonly role: string;\n}\n\nexport interface SemanticNode {\n  readonly children: readonly SemanticChild[];\n  readonly diagnostic?: string;\n  readonly kind: SemanticKind;\n  readonly label: string;\n  readonly path: StructuralPath;\n  readonly pointer: string;\n  readonly quoted: boolean;\n  readonly relationships: readonly SemanticRelationship[];\n  readonly specialForm?: SpecialFormName;\n  readonly value?: boolean | null | number | string;\n}\n\ninterface FormDefinition {\n  readonly matches: (value: unknown) => boolean;\n  readonly name: SpecialFormName;\n  readonly role: (index: number, length: number) => string;\n}\n\nconst roleByIndex =\n  (roles: readonly string[], fallback: string) => (index: number) =>\n    roles[index] ?? fallback;\n\nconst SPECIAL_FORMS: readonly FormDefinition[] = [\n  {\n    name: \"eval\",\n    matches: Schema.is(EvalFormSchema),\n    role: roleByIndex([\"operator\", \"expression\"], \"argument\"),\n  },\n  {\n    name: \"quote\",\n    matches: Schema.is(QuoteFormSchema),\n    role: roleByIndex([\"operator\", \"quoted-value\"], \"quoted-value\"),\n  },\n  {\n    name: \"begin\",\n    matches: Schema.is(BeginFormSchema),\n    role: roleByIndex([\"operator\"], \"sequence-item\"),\n  },\n  {\n    name: \"define\",\n    matches: Schema.is(DefineFormSchema),\n    role: roleByIndex([\"operator\", \"binding\", \"value\"], \"value\"),\n  },\n  {\n    name: \"lambda\",\n    matches: Schema.is(LambdaFormSchema),\n    role: roleByIndex([\"operator\", \"parameters\", \"body\"], \"body\"),\n  },\n  {\n    name: \"cond\",\n    matches: Schema.is(CondFormSchema),\n    role: roleByIndex([\"operator\"], \"branch\"),\n  },\n  {\n    name: \"match\",\n    matches: Schema.is(MatchFormSchema),\n    role: (index, length) => {\n      if (index === 0) {\n        return \"operator\";\n      }\n      if (index === 1) {\n        return \"subject\";\n      }\n      return index === length - 1 ? \"fallback\" : \"pattern\";\n    },\n  },\n];\n\nconst SPECIAL_FORM_NAMES: Readonly<Record<SpecialFormName, true>> = {\n  begin: true,\n  cond: true,\n  define: true,\n  eval: true,\n  lambda: true,\n  match: true,\n  quote: true,\n};\n\nconst escapePointerSegment = (segment: number | string) =>\n  String(segment).replaceAll(\"~\", \"~0\").replaceAll(\"/\", \"~1\");\n\nexport const pathToPointer = (path: StructuralPath): string =>\n  path.length === 0 ? \"\" : `/${path.map(escapePointerSegment).join(\"/\")}`;\n\nconst primitiveLabel = (value: boolean | null | number | string) => {\n  if (typeof value === \"string\") {\n    return JSON.stringify(value);\n  }\n  return String(value);\n};\n\nconst analyzeNode = (\n  expression: LionExpressionType,\n  path: StructuralPath,\n  quoted: boolean\n): SemanticNode => {\n  if (\n    !Array.isArray(expression) &&\n    (expression === null || typeof expression !== \"object\")\n  ) {\n    const relationships: SemanticRelationship[] = [];\n    if (typeof expression === \"string\") {\n      relationships.push({ kind: \"reference-candidate\", name: expression });\n    }\n    return {\n      path,\n      pointer: pathToPointer(path),\n      kind: \"primitive\",\n      label: primitiveLabel(expression),\n      value: expression,\n      quoted,\n      children: [],\n      relationships,\n    };\n  }\n\n  if (!Array.isArray(expression)) {\n    const entries = Object.entries(expression);\n    return {\n      path,\n      pointer: pathToPointer(path),\n      kind: \"record\",\n      label:\n        entries.length === 0 ? \"empty record\" : `record · ${entries.length}`,\n      quoted,\n      children: entries.map(([key, value], order) => ({\n        role: key,\n        order,\n        node: analyzeNode(value, [...path, key], quoted),\n      })),\n      relationships: [],\n    };\n  }\n\n  if (expression.length === 0) {\n    return {\n      path,\n      pointer: pathToPointer(path),\n      kind: \"empty-array\",\n      label: \"empty array\",\n      quoted,\n      children: [],\n      relationships: [],\n    };\n  }\n\n  const head = expression[0];\n  const namedForm = SPECIAL_FORMS.find(({ name }) => name === head);\n  const validForm = SPECIAL_FORMS.find(({ matches }) => matches(expression));\n  const relationships: SemanticRelationship[] = [];\n  if (\n    !quoted &&\n    validForm?.name === \"define\" &&\n    typeof expression[1] === \"string\"\n  ) {\n    relationships.push({ kind: \"definition\", name: expression[1] });\n  }\n  const role = quoted\n    ? () => \"item\"\n    : (validForm?.role ?? roleByIndex([\"callee\"], \"argument\"));\n  const children = expression.map((value, order) => ({\n    role: role(order, expression.length),\n    order,\n    node: analyzeNode(\n      value,\n      [...path, order],\n      quoted || (validForm?.name === \"quote\" && order > 0)\n    ),\n  }));\n\n  if (quoted) {\n    return {\n      path,\n      pointer: pathToPointer(path),\n      kind: \"array\",\n      label: `array · ${expression.length}`,\n      quoted,\n      children,\n      relationships,\n    };\n  }\n\n  if (!quoted && namedForm && !validForm) {\n    return {\n      path,\n      pointer: pathToPointer(path),\n      kind: \"invalid-call\",\n      label: `invalid ${namedForm.name}`,\n      specialForm: namedForm.name,\n      quoted,\n      children,\n      relationships,\n      diagnostic: `The ${namedForm.name} form has an invalid structure.`,\n    };\n  }\n\n  if (!quoted && validForm) {\n    return {\n      path,\n      pointer: pathToPointer(path),\n      kind: \"special-form\",\n      label: validForm.name,\n      specialForm: validForm.name,\n      quoted,\n      children,\n      relationships,\n    };\n  }\n\n  const label = typeof head === \"string\" ? head : \"call\";\n  return {\n    path,\n    pointer: pathToPointer(path),\n    kind: \"call\",\n    label,\n    quoted,\n    children,\n    relationships,\n  };\n};\n\nexport const isSpecialFormName = (value: unknown): value is SpecialFormName =>\n  typeof value === \"string\" &&\n  Object.hasOwn(SPECIAL_FORM_NAMES, value as SpecialFormName);\n\nexport const analyze = (expression: LionExpressionType): SemanticNode =>\n  analyzeNode(expression, [], false);\n\nexport const flattenAnalysis = (\n  root: SemanticNode\n): readonly SemanticNode[] => {\n  const nodes: SemanticNode[] = [];\n  const visit = (node: SemanticNode) => {\n    nodes.push(node);\n    for (const child of node.children) {\n      visit(child.node);\n    }\n  };\n  visit(root);\n  return nodes;\n};\n"],"mappings":"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"}

package/dist/environment-BQw8BPXl.d.mts

@@ -0,0 +1,25 @@
+import { Ref, Schema } from "effect";
+
+//#region src/schemas/environment.d.ts
+type BindingsRef = Ref.Ref<Record<string, unknown>>;
+interface InnerEnvironment {
+  readonly bindingsRef: BindingsRef;
+  readonly parent: Environment;
+}
+type Environment = typeof EnvironmentSchema.Type;
+type ToplevelEnvironment = typeof ToplevelEnvironmentSchema.Type;
+declare const ToplevelEnvironmentSchema: Schema.Struct<{
+  readonly bindingsRef: Schema.Codec<BindingsRef, BindingsRef, never, never>;
+}>;
+declare const EnvironmentSchema: Schema.Union<readonly [Schema.Struct<{
+  readonly bindingsRef: Schema.Codec<BindingsRef, BindingsRef, never, never>;
+}>, Schema.suspend<Schema.Codec<InnerEnvironment, InnerEnvironment, never, never>>]>;
+declare const InnerEnvironmentSchema: Schema.Struct<{
+  readonly bindingsRef: Schema.Codec<BindingsRef, BindingsRef, never, never>;
+  readonly parent: Schema.Union<readonly [Schema.Struct<{
+    readonly bindingsRef: Schema.Codec<BindingsRef, BindingsRef, never, never>;
+  }>, Schema.suspend<Schema.Codec<InnerEnvironment, InnerEnvironment, never, never>>]>;
+}>;
+//#endregion
+export { ToplevelEnvironment as a, InnerEnvironmentSchema as i, EnvironmentSchema as n, ToplevelEnvironmentSchema as o, InnerEnvironment as r, Environment as t };
+//# sourceMappingURL=environment-BQw8BPXl.d.mts.map

package/dist/{environment-k2Uf6VVc.d.mts.map → environment-BQw8BPXl.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"environment-k2Uf6VVc.d.mts","names":[],"sources":["../src/schemas/environment.ts"],"mappings":";;;KAEK,WAAA,GAAc,GAAA,CAAI,GAAA,CAAI,MAAA;AAAA,UAQV,gBAAA;EAAA,SACN,WAAA,EAAa,WAAA;EAAA,SACb,MAAA,EAAQ,WAAA;AAAA;AAAA,KAGP,WAAA,UAAqB,iBAAA,CAAkB,IAAA;AAAA,KAEvC,mBAAA,UAA6B,yBAAA,CAA0B,IAAA;AAAA,cAEtD,yBAAA,EAAyB,MAAA,CAAA,MAAA;;;cAIzB,iBAAA,EAAiB,MAAA,CAAA,KAAA,EAAA,MAAA,CAAA,MAAA;;;cAKjB,sBAAA,EAAsB,MAAA,CAAA,MAAA"}
+{"version":3,"file":"environment-BQw8BPXl.d.mts","names":[],"sources":["../src/schemas/environment.ts"],"mappings":";;;KAEK,WAAA,GAAc,GAAA,CAAI,GAAA,CAAI,MAAA;AAAA,UAQV,gBAAA;EAAA,SACN,WAAA,EAAa,WAAA;EAAA,SACb,MAAA,EAAQ,WAAA;AAAA;AAAA,KAGP,WAAA,UAAqB,iBAAA,CAAkB,IAAA;AAAA,KAEvC,mBAAA,UAA6B,yBAAA,CAA0B,IAAA;AAAA,cAEtD,yBAAA,EAAyB,MAAA,CAAA,MAAA;EAAA;;cAIzB,iBAAA,EAAiB,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA;EAAA;;cAKjB,sBAAA,EAAsB,MAAA,CAAA,MAAA;EAAA"}

package/dist/errors/evaluation.d.mts

@@ -1,2 +1,2 @@
-import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../evaluation-AblffSQw.mjs";
+import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../evaluation-B6K0DbPS.mjs";
 export { ArgumentMismatchError, InvalidFunctionCallError };

package/dist/errors/evaluation.mjs

@@ -1,8 +1,8 @@
 import { LionExpressionSchema } from "../schemas/lion-expression.mjs";
 import { Schema } from "effect";
 //#region src/errors/evaluation.ts
-var ArgumentMismatchError = class extends Schema.TaggedError("ArgumentMismatchError")("ArgumentMismatchError", {}) {};
-var InvalidFunctionCallError = class extends Schema.TaggedError("InvalidFunctionCallError")("InvalidFunctionCallError", { expression: LionExpressionSchema }) {};
+var ArgumentMismatchError = class extends Schema.TaggedError()("ArgumentMismatchError", {}) {};
+var InvalidFunctionCallError = class extends Schema.TaggedError()("InvalidFunctionCallError", { expression: LionExpressionSchema }) {};
 //#endregion
 export { ArgumentMismatchError, InvalidFunctionCallError };
 

package/dist/errors/evaluation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"evaluation.mjs","names":[],"sources":["../../src/errors/evaluation.ts"],"sourcesContent":["import { Schema } from \"effect\";\nimport { LionExpressionSchema } from \"@/schemas/lion-expression\";\n\nexport class ArgumentMismatchError extends Schema.TaggedError<ArgumentMismatchError>(\n  \"ArgumentMismatchError\"\n)(\"ArgumentMismatchError\", {}) {}\n\nexport class InvalidFunctionCallError extends Schema.TaggedError<InvalidFunctionCallError>(\n  \"InvalidFunctionCallError\"\n)(\"InvalidFunctionCallError\", { expression: LionExpressionSchema }) {}\n"],"mappings":";;;AAGA,IAAa,wBAAb,cAA2C,OAAO,YAChD,wBACD,CAAC,yBAAyB,EAAE,CAAC,CAAC;AAE/B,IAAa,2BAAb,cAA8C,OAAO,YACnD,2BACD,CAAC,4BAA4B,EAAE,YAAY,sBAAsB,CAAC,CAAC"}
+{"version":3,"file":"evaluation.mjs","names":[],"sources":["../../src/errors/evaluation.ts"],"sourcesContent":["import { Schema } from \"effect\";\nimport { LionExpressionSchema } from \"@/schemas/lion-expression\";\n\nexport class ArgumentMismatchError extends Schema.TaggedError<ArgumentMismatchError>()(\n  \"ArgumentMismatchError\",\n  {}\n) {}\n\nexport class InvalidFunctionCallError extends Schema.TaggedError<InvalidFunctionCallError>()(\n  \"InvalidFunctionCallError\",\n  { expression: LionExpressionSchema }\n) {}\n"],"mappings":";;;AAGA,IAAa,wBAAb,cAA2C,OAAO,aAAoC,CACpF,yBACA,EAAE,CACH,CAAC;AAEF,IAAa,2BAAb,cAA8C,OAAO,aAAuC,CAC1F,4BACA,EAAE,YAAY,sBAAsB,CACrC,CAAC"}

package/dist/{evaluate-D7ODMrbg.mjs → evaluate-BJOG7kaS.mjs}

@@ -1,9 +1,8 @@
-import { JsonPrimitiveSchema } from "./schemas/json-primitive.mjs";
 import { LionArrayExpressionSchema, LionExpressionSchema, LionRecordExpressionSchema } from "./schemas/lion-expression.mjs";
+import { BeginFormSchema, CondFormSchema, CondFormWithElseSchema, CondFormWithoutElseSchema, DefineFormSchema, EvalFormSchema, FunctionCallFormSchema, LambdaFormSchema, LionFunctionValueSchema, MatchFormSchema, MatchPatternSchema, QuoteFormSchema } from "./schemas/evaluation.mjs";
 import { ArgumentMismatchError, InvalidFunctionCallError } from "./errors/evaluation.mjs";
 import { makeEnvironment, setGlobalBinding } from "./evaluation/environment.mjs";
-import { BeginFormSchema, CondFormSchema, CondFormWithElseSchema, CondFormWithoutElseSchema, DefineFormSchema, EvalFormSchema, FunctionCallFormSchema, LambdaFormSchema, LionFunctionValueSchema, MatchFormSchema, MatchPatternSchema, QuoteFormSchema } from "./schemas/evaluation.mjs";
-import { LionEnvironmentService, getService } from "./services/evaluation.mjs";
+import { LionEnvironmentService } from "./services/evaluation.mjs";
 import { evaluateQuote } from "./evaluation/special-forms/quote.mjs";
 import { evaluatePrimitive } from "./evaluation/base-forms/primitive.mjs";
 import { Array, Effect, Match, Option, Record, Schema, pipe } from "effect";
@@ -22,10 +21,10 @@ const evaluateCond = (expression) => pipe(Match.value(expression), Match.when(Sc
 })), Match.exhaustive);
 //#endregion
 //#region src/evaluation/special-forms/define.ts
-const evaluateDefine = ([_, id, expr]) => pipe(Effect.Do, Effect.bind("environment", () => getService(LionEnvironmentService)), Effect.bind("value", () => evaluate(expr)), Effect.flatMap(({ environment, value }) => pipe(setGlobalBinding(environment, id, value), Effect.map(() => value))));
+const evaluateDefine = ([_, id, expr]) => pipe(Effect.Do, Effect.bind("environment", () => Effect.service(LionEnvironmentService)), Effect.bind("value", () => evaluate(expr)), Effect.flatMap(({ environment, value }) => pipe(setGlobalBinding(environment, id, value), Effect.map(() => value))));
 //#endregion
 //#region src/evaluation/special-forms/eval.ts
-const evaluateEval = ([_, args]) => pipe(evaluate(args), Effect.flatMap(Schema.decodeUnknown(LionExpressionSchema)), Effect.flatMap(evaluate));
+const evaluateEval = ([_, args]) => pipe(evaluate(args), Effect.flatMap(Schema.decodeUnknownEffect(LionExpressionSchema)), Effect.flatMap(evaluate));
 //#endregion
 //#region src/evaluation/special-forms/function.ts
 const evaluateFunctionCall = (functionCallExpression) => pipe(Effect.all(Array.map(functionCallExpression, evaluate)), Effect.map(Array.unprepend), Effect.flatMap(([head, tail]) => pipe(Match.value(head), Match.when(Schema.is(LionFunctionValueSchema), (fn) => {
@@ -35,7 +34,7 @@ const evaluateFunctionCall = (functionCallExpression) => pipe(Effect.all(Array.m
 //#endregion
 //#region src/evaluation/special-forms/lambda.ts
 const evaluateLambda = ([_, parameters, bodyExpression]) => Effect.gen(function* () {
-	const enclosedEnvironment = yield* getService(LionEnvironmentService);
+	const enclosedEnvironment = yield* LionEnvironmentService;
 	return Effect.fn(function* (...args) {
 		if (args.length < parameters.length) return yield* new ArgumentMismatchError();
 		const environment = yield* makeEnvironment(Record.fromEntries(Array.zip(parameters, args)), enclosedEnvironment);
@@ -44,41 +43,45 @@ const evaluateLambda = ([_, parameters, bodyExpression]) => Effect.gen(function*
 });
 //#endregion
 //#region src/evaluation/special-forms/match.ts
-const MatchPredicateRecordSchema = Schema.Record({
-	key: Schema.String,
-	value: Schema.suspend(() => MatchPredicateSchema)
-});
-const MatchPredicateSchema = Schema.Union(MatchPredicateRecordSchema, LionFunctionValueSchema);
-const AnyRecordSchema = Schema.Record({
-	key: Schema.String,
-	value: Schema.Any
-});
-const evaluatePredicate = (value, predicate) => pipe(Match.value(predicate), Match.when(Schema.is(MatchPredicateRecordSchema), (record) => Effect.gen(function* () {
-	if (!Schema.is(AnyRecordSchema)(value)) return false;
-	if (!Record.keys(record).every((key) => Record.has(value, key))) return false;
-	let result = true;
-	for (const [recordKey, recordValue] of Record.toEntries(record)) {
-		const recordValueResult = yield* evaluatePredicate(value[recordKey], recordValue);
-		result = result && recordValueResult;
+const MatchPredicateRecordSchema = Schema.Record(Schema.String, Schema.suspend(() => MatchPredicateSchema));
+const MatchPredicateSchema = Schema.Union([MatchPredicateRecordSchema, LionFunctionValueSchema]);
+const AnyRecordSchema = Schema.Record(Schema.String, Schema.Any);
+const evaluatePredicate = (value, predicate) => {
+	if (Schema.is(MatchPredicateRecordSchema)(predicate)) return Effect.gen(function* () {
+		if (!Schema.is(AnyRecordSchema)(value)) return false;
+		if (!Record.keys(predicate).every((key) => Record.has(value, key))) return false;
+		for (const [key, nestedPredicate] of Record.toEntries(predicate)) if (!(yield* evaluatePredicate(value[key], nestedPredicate))) return false;
+		return true;
+	});
+	return predicate(value).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.Boolean)), Effect.catch(() => Effect.succeed(false)));
+};
+const evaluateMatchPatterns = (value, patternExprs) => Effect.gen(function* () {
+	const patternExpr = patternExprs[0];
+	if (patternExpr === void 0) return yield* Effect.die(/* @__PURE__ */ new Error("Match expression requires a fallback function"));
+	if (Schema.is(MatchPatternSchema)(patternExpr)) {
+		const [predicateExpr, functionExpr] = patternExpr;
+		const predicate = yield* evaluate(predicateExpr).pipe(Effect.flatMap(Schema.decodeUnknownEffect(MatchPredicateSchema)));
+		const fn = yield* evaluate(functionExpr).pipe(Effect.flatMap(Schema.decodeUnknownEffect(LionFunctionValueSchema)));
+		return (yield* evaluatePredicate(value, predicate)) ? yield* fn(value) : yield* evaluateMatchPatterns(value, patternExprs.slice(1));
 	}
-	return result;
-})), Match.when(Schema.is(LionFunctionValueSchema), (predicateFn) => pipe(predicateFn(value), Effect.flatMap(Schema.decodeUnknown(Schema.Boolean)), Effect.catchAll(() => Effect.succeed(false)))), Match.orElseAbsurd);
-const evaluateMatchPatterns = (value, patternExprs) => pipe(Array.head(patternExprs), Option.getOrThrow, Match.value, Match.when(Schema.is(MatchPatternSchema), ([predicateExpr, fnExpr]) => pipe(Effect.Do, Effect.bind("predicate", () => evaluate(predicateExpr)), Effect.bind("fn", () => pipe(evaluate(fnExpr), Effect.flatMap(Schema.decodeUnknown(LionFunctionValueSchema)))), Effect.flatMap(({ predicate, fn }) => pipe(Schema.decodeUnknown(MatchPredicateSchema)(predicate), Effect.flatMap((predicate) => evaluatePredicate(value, predicate)), Effect.if({
-	onTrue: () => fn(value),
-	onFalse: () => pipe(Array.tail(patternExprs), Option.getOrThrow, (tail) => evaluateMatchPatterns(value, tail))
-}))))), Match.when(Schema.is(LionExpressionSchema), (fallbackFn) => pipe(evaluate(fallbackFn), Effect.flatMap(Schema.decodeUnknown(LionFunctionValueSchema)), Effect.flatMap((fallbackFn) => fallbackFn(value)))), Match.exhaustive);
-const evaluateMatch = ([_, valueExpr, ...patternExprs]) => pipe(evaluate(valueExpr), Effect.flatMap((value) => evaluateMatchPatterns(value, patternExprs)));
+	return yield* (yield* evaluate(patternExpr).pipe(Effect.flatMap(Schema.decodeUnknownEffect(LionFunctionValueSchema))))(value);
+});
+const evaluateMatch = ([_, valueExpression, ...patternExpressions]) => evaluate(valueExpression).pipe(Effect.flatMap((value) => evaluateMatchPatterns(value, patternExpressions)));
 //#endregion
 //#region src/evaluation/base-forms/array.ts
-const evaluateArray = (expression) => pipe(Match.value(expression), Match.when(Array.isEmptyReadonlyArray, Effect.succeed), Match.when(Schema.is(EvalFormSchema), (_) => evaluateEval(_)), Match.when(Schema.is(QuoteFormSchema), (_) => evaluateQuote(_)), Match.when(Schema.is(BeginFormSchema), (_) => evaluateBegin(_)), Match.when(Schema.is(DefineFormSchema), (_) => evaluateDefine(_)), Match.when(Schema.is(LambdaFormSchema), (_) => evaluateLambda(_)), Match.when(Schema.is(CondFormSchema), (_) => evaluateCond(_)), Match.when(Schema.is(MatchFormSchema), (_) => evaluateMatch(_)), Match.when(Schema.is(FunctionCallFormSchema), (_) => evaluateFunctionCall(_)), Match.orElse(() => Effect.fail(new InvalidFunctionCallError({ expression }))));
+const evaluateArray = (expression) => pipe(Match.value(expression), Match.when(Array.isReadonlyArrayEmpty, Effect.succeed), Match.when(Schema.is(EvalFormSchema), (_) => evaluateEval(_)), Match.when(Schema.is(QuoteFormSchema), (_) => evaluateQuote(_)), Match.when(Schema.is(BeginFormSchema), (_) => evaluateBegin(_)), Match.when(Schema.is(DefineFormSchema), (_) => evaluateDefine(_)), Match.when(Schema.is(LambdaFormSchema), (_) => evaluateLambda(_)), Match.when(Schema.is(CondFormSchema), (_) => evaluateCond(_)), Match.when(Schema.is(MatchFormSchema), (_) => evaluateMatch(_)), Match.when(Schema.is(FunctionCallFormSchema), (_) => evaluateFunctionCall(_)), Match.orElse(() => Effect.fail(new InvalidFunctionCallError({ expression }))));
 //#endregion
 //#region src/evaluation/base-forms/record.ts
 const evaluateRecord = (expression) => pipe(expression, Record.map(evaluate), Effect.all);
 //#endregion
 //#region src/evaluation/evaluate.ts
-const evaluate = (expression) => pipe(Match.value(expression), Match.when(Schema.is(LionArrayExpressionSchema), (_) => evaluateArray(_)), Match.when(Schema.is(LionRecordExpressionSchema), (_) => evaluateRecord(_)), Match.when(Schema.is(JsonPrimitiveSchema), (_) => evaluatePrimitive(_)), Match.exhaustive);
-const run = (expression, environment) => pipe(Schema.decodeUnknown(LionExpressionSchema)(expression), Effect.flatMap(evaluate), Effect.provideServiceEffect(LionEnvironmentService, makeEnvironment(environment)));
+const evaluate = (expression) => {
+	if (Schema.is(LionArrayExpressionSchema)(expression)) return evaluateArray(expression);
+	if (Schema.is(LionRecordExpressionSchema)(expression)) return evaluateRecord(expression);
+	return evaluatePrimitive(expression);
+};
+const run = (expression, environment) => pipe(Schema.decodeUnknownEffect(LionExpressionSchema)(expression), Effect.flatMap(evaluate), Effect.provideServiceEffect(LionEnvironmentService, makeEnvironment(environment)));
 //#endregion
 export { evaluateMatch as a, evaluateEval as c, evaluateBegin as d, evaluateArray as i, evaluateDefine as l, run as n, evaluateLambda as o, evaluateRecord as r, evaluateFunctionCall as s, evaluate as t, evaluateCond as u };
 
-//# sourceMappingURL=evaluate-D7ODMrbg.mjs.map
+//# sourceMappingURL=evaluate-BJOG7kaS.mjs.map

package/dist/evaluate-BJOG7kaS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate-BJOG7kaS.mjs","names":["Arr","Arr","Arr","Arr","Arr"],"sources":["../src/evaluation/special-forms/begin.ts","../src/evaluation/special-forms/cond.ts","../src/evaluation/special-forms/define.ts","../src/evaluation/special-forms/eval.ts","../src/evaluation/special-forms/function.ts","../src/evaluation/special-forms/lambda.ts","../src/evaluation/special-forms/match.ts","../src/evaluation/base-forms/array.ts","../src/evaluation/base-forms/record.ts","../src/evaluation/evaluate.ts"],"sourcesContent":["import { Array as Arr, Effect, Option, pipe } from \"effect\";\nimport { evaluate } from \"@/evaluation/evaluate\";\nimport type { BeginFormSchema } from \"@/schemas/evaluation\";\n\nexport const evaluateBegin = ([_, ...args]: typeof BeginFormSchema.Type) =>\n  pipe(\n    Arr.map(args, evaluate),\n    Effect.all,\n    Effect.map(Arr.last),\n    Effect.map(Option.getOrElse(() => []))\n  );\n","import { Array as Arr, Effect, Match, pipe, Schema } from \"effect\";\nimport { evaluate } from \"@/evaluation/evaluate\";\nimport {\n  type CondFormSchema,\n  CondFormWithElseSchema,\n  CondFormWithoutElseSchema,\n} from \"@/schemas/evaluation\";\n\nexport const evaluateCond = (expression: typeof CondFormSchema.Type) =>\n  pipe(\n    Match.value(expression),\n    Match.when(Schema.is(CondFormWithoutElseSchema), (exprWithoutElse) =>\n      Effect.gen(function* () {\n        const [_, ...cases] = exprWithoutElse;\n        for (const [condition, result] of cases) {\n          const conditionResult = yield* evaluate(condition);\n          if (conditionResult) {\n            return yield* evaluate(result);\n          }\n        }\n        return null;\n      })\n    ),\n    Match.when(Schema.is(CondFormWithElseSchema), (expression) =>\n      Effect.gen(function* () {\n        const [_, ...cases] = expression;\n        for (const [condition, result] of Arr.initNonEmpty(cases)) {\n          const conditionResult = yield* evaluate(condition);\n          if (conditionResult) {\n            return yield* evaluate(result);\n          }\n        }\n        const elseCase = Arr.lastNonEmpty(cases);\n        return yield* evaluate(elseCase);\n      })\n    ),\n    Match.exhaustive\n  );\n","import { Effect, pipe } from \"effect\";\nimport { setGlobalBinding } from \"@/evaluation/environment\";\nimport { evaluate } from \"@/evaluation/evaluate\";\nimport type { DefineFormSchema } from \"@/schemas/evaluation\";\nimport { LionEnvironmentService } from \"@/services/evaluation\";\n\nexport const evaluateDefine = ([_, id, expr]: typeof DefineFormSchema.Type) =>\n  pipe(\n    Effect.Do,\n    Effect.bind(\"environment\", () => Effect.service(LionEnvironmentService)),\n    Effect.bind(\"value\", () => evaluate(expr)),\n    Effect.flatMap(({ environment, value }) =>\n      pipe(\n        setGlobalBinding(environment, id, value),\n        Effect.map(() => value)\n      )\n    )\n  );\n","import { Effect, pipe, Schema } from \"effect\";\nimport { evaluate } from \"@/evaluation/evaluate.ts\";\nimport type { EvalFormSchema } from \"@/schemas/evaluation\";\nimport { LionExpressionSchema } from \"@/schemas/lion-expression\";\n\nexport const evaluateEval = ([_, args]: typeof EvalFormSchema.Type) =>\n  pipe(\n    evaluate(args),\n    Effect.flatMap(Schema.decodeUnknownEffect(LionExpressionSchema)),\n    Effect.flatMap(evaluate)\n  );\n","import { Array as Arr, Effect, Match, pipe, Schema } from \"effect\";\nimport { InvalidFunctionCallError } from \"@/errors/evaluation\";\nimport { evaluate } from \"@/evaluation/evaluate.ts\";\nimport {\n  type FunctionCallFormSchema,\n  LionFunctionValueSchema,\n} from \"@/schemas/evaluation\";\n\nexport const evaluateFunctionCall = (\n  functionCallExpression: typeof FunctionCallFormSchema.Type\n) =>\n  pipe(\n    Effect.all(Arr.map(functionCallExpression, evaluate)),\n    Effect.map(Arr.unprepend),\n    Effect.flatMap(([head, tail]) =>\n      pipe(\n        Match.value(head),\n        Match.when(Schema.is(LionFunctionValueSchema), (fn) => {\n          const result = fn(...tail);\n          return Effect.isEffect(result) ? result : Effect.succeed(result);\n        }),\n        Match.orElse(() =>\n          Effect.fail(\n            new InvalidFunctionCallError({ expression: functionCallExpression })\n          )\n        )\n      )\n    )\n  );\n","import { Array as Arr, Effect, Record } from \"effect\";\nimport { ArgumentMismatchError } from \"@/errors/evaluation\";\nimport { makeEnvironment } from \"@/evaluation/environment\";\nimport { evaluate } from \"@/evaluation/evaluate\";\nimport type { LambdaFormSchema } from \"@/schemas/evaluation\";\nimport { LionEnvironmentService } from \"@/services/evaluation\";\n\nexport const evaluateLambda = ([\n  _,\n  parameters,\n  bodyExpression,\n]: typeof LambdaFormSchema.Type) =>\n  Effect.gen(function* () {\n    const enclosedEnvironment = yield* LionEnvironmentService;\n    const lambda = Effect.fn(function* (...args: unknown[]) {\n      if (args.length < parameters.length) {\n        return yield* new ArgumentMismatchError();\n      }\n      const paramsEnvironment = Record.fromEntries(Arr.zip(parameters, args));\n      const environment = yield* makeEnvironment(\n        paramsEnvironment,\n        enclosedEnvironment\n      );\n      return yield* evaluate(bodyExpression).pipe(\n        Effect.provideService(LionEnvironmentService, environment)\n      );\n    });\n    return lambda;\n  });\n","import { Effect, Record, Schema } from \"effect\";\nimport { evaluate } from \"@/evaluation/evaluate\";\nimport {\n  LionFunctionValueSchema,\n  type MatchFormSchema,\n  MatchPatternSchema,\n} from \"@/schemas/evaluation\";\nimport type { LionExpressionSchema } from \"@/schemas/lion-expression\";\nimport type { LionEnvironmentService } from \"@/services/evaluation\";\nimport type { EvaluateResult } from \"@/types/evaluation\";\n\n/*\n[\"match\", <value>, [<predicate>, <fn>], ..., <fallback-fn>]\n*/\n\ntype AssumedMatchPredicateType =\n  | { readonly [key: string]: AssumedMatchPredicateType }\n  | typeof LionFunctionValueSchema.Type;\n\nconst MatchPredicateRecordSchema = Schema.Record(\n  Schema.String,\n  Schema.suspend(\n    (): Schema.Codec<AssumedMatchPredicateType> => MatchPredicateSchema\n  )\n);\n\nconst MatchPredicateSchema = Schema.Union([\n  MatchPredicateRecordSchema,\n  LionFunctionValueSchema,\n]);\n\nconst AnyRecordSchema = Schema.Record(Schema.String, Schema.Any);\n\nconst evaluatePredicate = (\n  value: unknown,\n  predicate: typeof MatchPredicateSchema.Type\n): Effect.Effect<boolean, never, LionEnvironmentService> => {\n  if (Schema.is(MatchPredicateRecordSchema)(predicate)) {\n    return Effect.gen(function* () {\n      if (!Schema.is(AnyRecordSchema)(value)) {\n        return false;\n      }\n\n      if (!Record.keys(predicate).every((key) => Record.has(value, key))) {\n        return false;\n      }\n\n      for (const [key, nestedPredicate] of Record.toEntries(predicate)) {\n        if (!(yield* evaluatePredicate(value[key], nestedPredicate))) {\n          return false;\n        }\n      }\n      return true;\n    });\n  }\n\n  return predicate(value).pipe(\n    Effect.flatMap(Schema.decodeUnknownEffect(Schema.Boolean)),\n    Effect.catch(() => Effect.succeed(false))\n  );\n};\n\nconst evaluateMatchPatterns = (\n  value: unknown,\n  patternExprs: ReadonlyArray<\n    typeof MatchPatternSchema.Type | typeof LionExpressionSchema.Type\n  >\n): EvaluateResult =>\n  Effect.gen(function* () {\n    const patternExpr = patternExprs[0];\n    if (patternExpr === undefined) {\n      return yield* Effect.die(\n        new Error(\"Match expression requires a fallback function\")\n      );\n    }\n\n    if (Schema.is(MatchPatternSchema)(patternExpr)) {\n      const [predicateExpr, functionExpr] = patternExpr;\n      const predicate = yield* evaluate(predicateExpr).pipe(\n        Effect.flatMap(Schema.decodeUnknownEffect(MatchPredicateSchema))\n      );\n      const fn = yield* evaluate(functionExpr).pipe(\n        Effect.flatMap(Schema.decodeUnknownEffect(LionFunctionValueSchema))\n      );\n      return (yield* evaluatePredicate(value, predicate))\n        ? yield* fn(value)\n        : yield* evaluateMatchPatterns(value, patternExprs.slice(1));\n    }\n\n    const fallback = yield* evaluate(patternExpr).pipe(\n      Effect.flatMap(Schema.decodeUnknownEffect(LionFunctionValueSchema))\n    );\n    return yield* fallback(value);\n  });\n\nexport const evaluateMatch = ([\n  _,\n  valueExpression,\n  ...patternExpressions\n]: typeof MatchFormSchema.Type) =>\n  evaluate(valueExpression).pipe(\n    Effect.flatMap((value) => evaluateMatchPatterns(value, patternExpressions))\n  );\n","import { Array as Arr, Effect, Match, pipe, Schema } from \"effect\";\nimport { InvalidFunctionCallError } from \"@/errors/evaluation\";\nimport { evaluateBegin } from \"@/evaluation/special-forms/begin.ts\";\nimport { evaluateCond } from \"@/evaluation/special-forms/cond.ts\";\nimport { evaluateDefine } from \"@/evaluation/special-forms/define.ts\";\nimport { evaluateEval } from \"@/evaluation/special-forms/eval.ts\";\nimport { evaluateFunctionCall } from \"@/evaluation/special-forms/function.ts\";\nimport { evaluateLambda } from \"@/evaluation/special-forms/lambda\";\nimport { evaluateMatch } from \"@/evaluation/special-forms/match\";\nimport { evaluateQuote } from \"@/evaluation/special-forms/quote.ts\";\nimport {\n  BeginFormSchema,\n  CondFormSchema,\n  DefineFormSchema,\n  EvalFormSchema,\n  FunctionCallFormSchema,\n  LambdaFormSchema,\n  MatchFormSchema,\n  QuoteFormSchema,\n} from \"@/schemas/evaluation.ts\";\nimport type { LionArrayExpressionType } from \"@/schemas/lion-expression.ts\";\n\nexport const evaluateArray = (expression: LionArrayExpressionType) =>\n  pipe(\n    Match.value(expression),\n    Match.when(Arr.isReadonlyArrayEmpty, Effect.succeed),\n    Match.when(Schema.is(EvalFormSchema), (_) => evaluateEval(_)),\n    Match.when(Schema.is(QuoteFormSchema), (_) => evaluateQuote(_)),\n    Match.when(Schema.is(BeginFormSchema), (_) => evaluateBegin(_)),\n    Match.when(Schema.is(DefineFormSchema), (_) => evaluateDefine(_)),\n    Match.when(Schema.is(LambdaFormSchema), (_) => evaluateLambda(_)),\n    Match.when(Schema.is(CondFormSchema), (_) => evaluateCond(_)),\n    Match.when(Schema.is(MatchFormSchema), (_) => evaluateMatch(_)),\n    Match.when(Schema.is(FunctionCallFormSchema), (_) =>\n      evaluateFunctionCall(_)\n    ),\n    Match.orElse(() =>\n      Effect.fail(new InvalidFunctionCallError({ expression }))\n    )\n  );\n","import { Effect, pipe, Record } from \"effect\";\nimport { evaluate } from \"@/evaluation/evaluate.ts\";\nimport type { LionRecordExpressionType } from \"@/schemas/lion-expression\";\n\nexport const evaluateRecord = (expression: LionRecordExpressionType) =>\n  pipe(expression, Record.map(evaluate), Effect.all);\n","import { Effect, pipe, Schema } from \"effect\";\nimport { evaluateArray } from \"@/evaluation/base-forms/array\";\nimport { evaluatePrimitive } from \"@/evaluation/base-forms/primitive\";\nimport { evaluateRecord } from \"@/evaluation/base-forms/record\";\nimport { makeEnvironment } from \"@/evaluation/environment\";\nimport {\n  LionArrayExpressionSchema,\n  LionExpressionSchema,\n  type LionExpressionType,\n  LionRecordExpressionSchema,\n} from \"@/schemas/lion-expression\";\nimport { LionEnvironmentService } from \"@/services/evaluation\";\nimport type { EvaluateResult } from \"@/types/evaluation\";\n\nexport const evaluate = (expression: LionExpressionType): EvaluateResult => {\n  if (Schema.is(LionArrayExpressionSchema)(expression)) {\n    return evaluateArray(expression);\n  }\n  if (Schema.is(LionRecordExpressionSchema)(expression)) {\n    return evaluateRecord(expression);\n  }\n  return evaluatePrimitive(expression);\n};\n\nexport const run = (\n  expression: unknown,\n  environment: Record<string, unknown>\n) =>\n  pipe(\n    Schema.decodeUnknownEffect(LionExpressionSchema)(expression),\n    Effect.flatMap(evaluate),\n    Effect.provideServiceEffect(\n      LionEnvironmentService,\n      makeEnvironment(environment)\n    )\n  );\n"],"mappings":"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"}

package/dist/evaluation/base-forms/array.d.mts

@@ -1,11 +1,10 @@
-import { r as LionArrayExpressionType } from "../../lion-expression-6Y3itx9l.mjs";
-import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-AblffSQw.mjs";
-import { t as LionEnvironmentService } from "../../evaluation-EqzK8tQV.mjs";
-import { Effect } from "effect";
-import * as _$effect_ParseResult0 from "effect/ParseResult";
+import { r as LionArrayExpressionType } from "../../lion-expression-DMR7Psmu.mjs";
+import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-B6K0DbPS.mjs";
+import { t as LionEnvironmentService } from "../../evaluation-Bs36vy1h.mjs";
+import { Effect, Schema } from "effect";
 
 //#region src/evaluation/base-forms/array.d.ts
-declare const evaluateArray: (expression: LionArrayExpressionType) => Effect.Effect<unknown, ArgumentMismatchError | InvalidFunctionCallError | _$effect_ParseResult0.ParseError, LionEnvironmentService>;
+declare const evaluateArray: (expression: LionArrayExpressionType) => Effect.Effect<unknown, Schema.SchemaError | ArgumentMismatchError | InvalidFunctionCallError, LionEnvironmentService>;
 //#endregion
 export { evaluateArray };
 //# sourceMappingURL=array.d.mts.map

package/dist/evaluation/base-forms/array.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"array.d.mts","names":[],"sources":["../../../src/evaluation/base-forms/array.ts"],"mappings":";;;;;;;cAsBa,aAAA,GAAiB,UAAA,EAAY,uBAAA,KAAuB,MAAA,CAAA,MAAA,UAAA,qBAAA,GAAA,wBAAA,GAAA,qBAAA,CAAA,UAAA,EAAA,sBAAA"}
+{"version":3,"file":"array.d.mts","names":[],"sources":["../../../src/evaluation/base-forms/array.ts"],"mappings":";;;;;;cAsBa,aAAA,GAAiB,UAAA,EAAY,uBAAA,KAAuB,MAAA,CAAA,MAAA,UAAA,MAAA,CAAA,WAAA,GAAA,qBAAA,GAAA,wBAAA,EAAA,sBAAA"}

package/dist/evaluation/base-forms/array.mjs

@@ -1,2 +1,2 @@
-import { i as evaluateArray } from "../../evaluate-D7ODMrbg.mjs";
+import { i as evaluateArray } from "../../evaluate-BJOG7kaS.mjs";
 export { evaluateArray };

package/dist/evaluation/base-forms/primitive.d.mts

@@ -1,5 +1,5 @@
-import { n as JsonPrimitiveType } from "../../json-primitive-DUaaoNff.mjs";
-import { t as LionEnvironmentService } from "../../evaluation-EqzK8tQV.mjs";
+import { n as JsonPrimitiveType } from "../../json-primitive-gcv9Q1E4.mjs";
+import { t as LionEnvironmentService } from "../../evaluation-Bs36vy1h.mjs";
 import { Effect } from "effect";
 
 //#region src/evaluation/base-forms/primitive.d.ts

package/dist/evaluation/base-forms/primitive.mjs

@@ -1,9 +1,9 @@
 import { getBinding } from "../environment.mjs";
-import { LionEnvironmentService, getService } from "../../services/evaluation.mjs";
+import { LionEnvironmentService } from "../../services/evaluation.mjs";
 import { Effect, Match, Option, String, pipe } from "effect";
 //#region src/evaluation/base-forms/primitive.ts
 const evaluatePrimitive = (expression) => pipe(Match.value(expression), Match.when(String.isString, evaluateReference), Match.orElse(Effect.succeed));
-const evaluateReference = (name) => pipe(getService(LionEnvironmentService), Effect.flatMap((environment) => getBinding(environment, name)), Effect.map(Option.getOrElse(() => name)));
+const evaluateReference = (name) => pipe(Effect.service(LionEnvironmentService), Effect.flatMap((environment) => getBinding(environment, name)), Effect.map(Option.getOrElse(() => name)));
 //#endregion
 export { evaluatePrimitive, evaluateReference };
 

package/dist/evaluation/base-forms/primitive.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"primitive.mjs","names":["Str"],"sources":["../../../src/evaluation/base-forms/primitive.ts"],"sourcesContent":["import { Effect, Match, Option, pipe, String as Str } from \"effect\";\nimport { getBinding } from \"@/evaluation/environment\";\nimport type { JsonPrimitiveType } from \"@/schemas/json-primitive\";\nimport { getService, LionEnvironmentService } from \"@/services/evaluation.ts\";\n\nexport const evaluatePrimitive = (expression: JsonPrimitiveType) =>\n  pipe(\n    Match.value(expression),\n    Match.when(Str.isString, evaluateReference),\n    Match.orElse(Effect.succeed)\n  );\n\nexport const evaluateReference = (name: string) =>\n  pipe(\n    getService(LionEnvironmentService),\n    Effect.flatMap((environment) => getBinding(environment, name)),\n    Effect.map(Option.getOrElse(() => name))\n  );\n"],"mappings":";;;;AAKA,MAAa,qBAAqB,eAChC,KACE,MAAM,MAAM,WAAW,EACvB,MAAM,KAAKA,OAAI,UAAU,kBAAkB,EAC3C,MAAM,OAAO,OAAO,QAAQ,CAC7B;AAEH,MAAa,qBAAqB,SAChC,KACE,WAAW,uBAAuB,EAClC,OAAO,SAAS,gBAAgB,WAAW,aAAa,KAAK,CAAC,EAC9D,OAAO,IAAI,OAAO,gBAAgB,KAAK,CAAC,CACzC"}
+{"version":3,"file":"primitive.mjs","names":["Str"],"sources":["../../../src/evaluation/base-forms/primitive.ts"],"sourcesContent":["import { Effect, Match, Option, pipe, String as Str } from \"effect\";\nimport { getBinding } from \"@/evaluation/environment\";\nimport type { JsonPrimitiveType } from \"@/schemas/json-primitive\";\nimport { LionEnvironmentService } from \"@/services/evaluation.ts\";\n\nexport const evaluatePrimitive = (expression: JsonPrimitiveType) =>\n  pipe(\n    Match.value(expression),\n    Match.when(Str.isString, evaluateReference),\n    Match.orElse(Effect.succeed)\n  );\n\nexport const evaluateReference = (name: string) =>\n  pipe(\n    Effect.service(LionEnvironmentService),\n    Effect.flatMap((environment) => getBinding(environment, name)),\n    Effect.map(Option.getOrElse(() => name))\n  );\n"],"mappings":";;;;AAKA,MAAa,qBAAqB,eAChC,KACE,MAAM,MAAM,WAAW,EACvB,MAAM,KAAKA,OAAI,UAAU,kBAAkB,EAC3C,MAAM,OAAO,OAAO,QAAQ,CAC7B;AAEH,MAAa,qBAAqB,SAChC,KACE,OAAO,QAAQ,uBAAuB,EACtC,OAAO,SAAS,gBAAgB,WAAW,aAAa,KAAK,CAAC,EAC9D,OAAO,IAAI,OAAO,gBAAgB,KAAK,CAAC,CACzC"}

package/dist/evaluation/base-forms/record.d.mts

@@ -1,13 +1,13 @@
-import { s as LionRecordExpressionType } from "../../lion-expression-6Y3itx9l.mjs";
-import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-AblffSQw.mjs";
-import { t as LionEnvironmentService } from "../../evaluation-EqzK8tQV.mjs";
+import { s as LionRecordExpressionType } from "../../lion-expression-DMR7Psmu.mjs";
+import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../../evaluation-B6K0DbPS.mjs";
+import { t as LionEnvironmentService } from "../../evaluation-Bs36vy1h.mjs";
 import { Effect } from "effect";
-import * as _$effect_ParseResult0 from "effect/ParseResult";
+import * as _$effect_Schema0 from "effect/Schema";
 
 //#region src/evaluation/base-forms/record.d.ts
 declare const evaluateRecord: (expression: LionRecordExpressionType) => Effect.Effect<{
   [x: string]: unknown;
-}, ArgumentMismatchError | InvalidFunctionCallError | _$effect_ParseResult0.ParseError, LionEnvironmentService>;
+}, _$effect_Schema0.SchemaError | ArgumentMismatchError | InvalidFunctionCallError, LionEnvironmentService>;
 //#endregion
 export { evaluateRecord };
 //# sourceMappingURL=record.d.mts.map

package/dist/evaluation/base-forms/record.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"record.d.mts","names":[],"sources":["../../../src/evaluation/base-forms/record.ts"],"mappings":";;;;;;;cAIa,cAAA,GAAkB,UAAA,EAAY,wBAAA,KAAwB,MAAA,CAAA,MAAA;EAAA;GAAA,qBAAA"}
+{"version":3,"file":"record.d.mts","names":[],"sources":["../../../src/evaluation/base-forms/record.ts"],"mappings":";;;;;;;cAIa,cAAA,GAAkB,UAAA,EAAY,wBAAA,KAAwB,MAAA,CAAA,MAAA;EAAA;GAAA,gBAAA,CAAA,WAAA"}

package/dist/evaluation/base-forms/record.mjs

@@ -1,2 +1,2 @@
-import { r as evaluateRecord } from "../../evaluate-D7ODMrbg.mjs";
+import { r as evaluateRecord } from "../../evaluate-BJOG7kaS.mjs";
 export { evaluateRecord };

package/dist/evaluation/environment.d.mts

@@ -1,4 +1,4 @@
-import { a as ToplevelEnvironment, r as InnerEnvironment, t as Environment } from "../environment-k2Uf6VVc.mjs";
+import { a as ToplevelEnvironment, r as InnerEnvironment, t as Environment } from "../environment-BQw8BPXl.mjs";
 import { Effect, Option } from "effect";
 
 //#region src/evaluation/environment.d.ts

package/dist/evaluation/environment.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"environment.d.mts","names":[],"sources":["../../src/evaluation/environment.ts"],"mappings":";;;;iBASgB,eAAA,CACd,QAAA,EAAU,MAAA,oBACT,MAAA,CAAO,MAAA,CAAO,mBAAA;AAAA,iBAED,eAAA,CACd,QAAA,EAAU,MAAA,mBACV,MAAA,EAAQ,WAAA,GACP,MAAA,CAAO,MAAA,CAAO,gBAAA;AAAA,cAeJ,UAAA,GACX,WAAA,EAAa,WAAA,EACb,IAAA,aACC,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,MAAA;AAAA,cAqBX,eAAA,GACX,WAAA,EAAa,WAAA,EACb,IAAA,UACA,KAAA,cACC,MAAA,CAAO,MAAA,CAAO,WAAA;AAAA,cAOJ,gBAAA,GACX,WAAA,EAAa,WAAA,EACb,IAAA,UACA,KAAA,cACC,MAAA,CAAO,MAAA,CAAO,WAAA"}
+{"version":3,"file":"environment.d.mts","names":[],"sources":["../../src/evaluation/environment.ts"],"mappings":";;;;iBAWgB,eAAA,CACd,QAAA,EAAU,MAAA,oBACT,MAAA,CAAO,MAAA,CAAO,mBAAA;AAAA,iBAED,eAAA,CACd,QAAA,EAAU,MAAA,mBACV,MAAA,EAAQ,WAAA,GACP,MAAA,CAAO,MAAA,CAAO,gBAAA;AAAA,cAeJ,UAAA,GACX,WAAA,EAAa,WAAA,EACb,IAAA,aACC,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,MAAA;AAAA,cAcX,eAAA,GACX,WAAA,EAAa,WAAA,EACb,IAAA,UACA,KAAA,cACC,MAAA,CAAO,MAAA,CAAO,WAAA;AAAA,cAOJ,gBAAA,GACX,WAAA,EAAa,WAAA,EACb,IAAA,UACA,KAAA,cACC,MAAA,CAAO,MAAA,CAAO,WAAA"}

package/dist/evaluation/environment.mjs

@@ -1,18 +1,21 @@
-import { InnerEnvironmentSchema, ToplevelEnvironmentSchema } from "../schemas/environment.mjs";
-import { Effect, Match, Option, Record, Ref, Schema, pipe } from "effect";
+import { Effect, Option, Record, Ref, pipe } from "effect";
 //#region src/evaluation/environment.ts
+const isInnerEnvironment = (environment) => "parent" in environment;
 function makeEnvironment(bindings, parent) {
 	return Ref.make(bindings).pipe(Effect.map((bindingsRef) => typeof parent === "undefined" ? { bindingsRef } : {
 		bindingsRef,
 		parent
 	}));
 }
-const getBinding = (environment, name) => pipe(Match.value(environment), Match.when(Schema.is(InnerEnvironmentSchema), ({ bindingsRef, parent }) => pipe(Ref.get(bindingsRef), Effect.map(Record.get(name)), Effect.flatMap(Option.match({
-	onSome: (binding) => Effect.succeed(Option.some(binding)),
-	onNone: () => getBinding(parent, name)
-})))), Match.when(Schema.is(ToplevelEnvironmentSchema), ({ bindingsRef }) => pipe(Ref.get(bindingsRef), Effect.map(Record.get(name)))), Match.exhaustive);
+const getBinding = (environment, name) => Effect.gen(function* () {
+	const binding = yield* pipe(Ref.get(environment.bindingsRef), Effect.map(Record.get(name)));
+	if (Option.isSome(binding)) return binding;
+	return isInnerEnvironment(environment) ? yield* getBinding(environment.parent, name) : Option.none();
+});
 const setLocalBinding = (environment, name, value) => pipe(environment.bindingsRef, Ref.update(Record.set(name, value)), Effect.as(environment));
-const setGlobalBinding = (environment, name, value) => pipe(Match.value(environment), Match.when(Schema.is(InnerEnvironmentSchema), ({ parent }) => setGlobalBinding(parent, name, value)), Match.when(Schema.is(ToplevelEnvironmentSchema), ({ bindingsRef }) => Ref.update(bindingsRef, Record.set(name, value))), Match.exhaustive, Effect.map(() => environment));
+const setGlobalBinding = (environment, name, value) => {
+	return (isInnerEnvironment(environment) ? setGlobalBinding(environment.parent, name, value) : Ref.update(environment.bindingsRef, Record.set(name, value))).pipe(Effect.as(environment));
+};
 //#endregion
 export { getBinding, makeEnvironment, setGlobalBinding, setLocalBinding };