@mojir/dvala 0.0.29 → 0.0.31

package/dist/cli/cli.js

@@ -119,7 +119,8 @@ const NodeTypes = {
 	ReservedSymbol: 8,
 	Binding: 9,
 	Spread: 10,
-	TemplateString: 11
+	TemplateString: 11,
+	EffectName: 12
 };
 const NodeTypesSet = new Set(Object.values(NodeTypes));
 function getNodeTypeName(type) {
@@ -478,7 +479,7 @@ function findAllOccurrences(input, pattern) {
 }
 //#endregion
 //#region package.json
-var version = "0.0.29";
+var version = "0.0.31";
 //#endregion
 //#region src/typeGuards/string.ts
 function isString(value, options = {}) {
@@ -527,7 +528,7 @@ const assertionNormalExpression = { assert: {
 			message: { type: "string" }
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
-		examples: ["do assert(0, \"Expected a positive value\") with case effect(dvala.error) then ([msg]) -> msg end"],
+		examples: ["do assert(0, \"Expected a positive value\") with case @dvala.error then ([msg]) -> msg end"],
 		seeAlso: ["assertion.assert-truthy", "assertion.assert-true"],
 		hideOperatorForm: true
 	}
@@ -3580,7 +3581,7 @@ const miscNormalExpression = {
 			variants: [{ argumentNames: ["e"] }],
 			description: "Returns the name of an effect reference as a string.",
 			seeAlso: ["effect-matcher", "effect?"],
-			examples: ["effect-name(effect(dvala.error))", "effect-name(effect(llm.complete))"]
+			examples: ["effect-name(@dvala.error)", "effect-name(@llm.complete)"]
 		}
 	},
 	"effect-matcher": {
@@ -3617,9 +3618,9 @@ const miscNormalExpression = {
 			description: "Returns a predicate function that matches effects by name. If $pattern is a string, uses wildcard matching: no wildcard means exact match, `.*` suffix matches the prefix and all descendants (dot boundary enforced), and `*` alone matches everything. If $pattern is a regexp, tests the effect name against the regexp.",
 			seeAlso: ["effect-name", "effect?"],
 			examples: [
-				"let pred = effect-matcher(\"dvala.*\"); pred(effect(dvala.error))",
-				"let pred = effect-matcher(\"dvala.*\"); pred(effect(custom.foo))",
-				"let pred = effect-matcher(\"*\"); pred(effect(anything))"
+				"let pred = effect-matcher(\"dvala.*\"); pred(@dvala.error)",
+				"let pred = effect-matcher(\"dvala.*\"); pred(@custom.foo)",
+				"let pred = effect-matcher(\"*\"); pred(@anything)"
 			]
 		}
 	},
@@ -3665,7 +3666,7 @@ const miscNormalExpression = {
 				"type-of({ a: 1 })",
 				"type-of((x) -> x + 1)",
 				"type-of(regexp(\"^start\"))",
-				"type-of(effect(dvala.io.println))"
+				"type-of(@dvala.io.println)"
 			]
 		}
 	}
@@ -4410,7 +4411,7 @@ const predicatesNormalExpression = {
 				"type-of"
 			],
 			examples: [
-				"effect?(effect(dvala.io.println))",
+				"effect?(@dvala.io.println)",
 				"effect?(42)",
 				"effect?(\"hello\")",
 				"effect?(null)",
@@ -5241,7 +5242,7 @@ function signature(reference) {
 	const { title, variants, args, returns } = reference;
 	const isOperator = !isEffectRef(reference) && reference._isOperator;
 	const functionForms = variants.map((variant) => {
-		if (isEffectRef(reference)) return `  perform(effect(${title})${variant.argumentNames.length > 0 ? `, ${variant.argumentNames.map((argName) => {
+		if (isEffectRef(reference)) return `  perform(@${title}${variant.argumentNames.length > 0 ? `, ${variant.argumentNames.map((argName) => {
 			let result = "";
 			if (args[argName].rest) result += "...";
 			result += argName;
@@ -5299,7 +5300,7 @@ function getMetaNormalExpression(normalExpressionReference, effectReference) {
 				seeAlso: ["arity", "with-doc"],
 				examples: [
 					"doc(+)",
-					"doc(effect(dvala.io.println))",
+					"doc(@dvala.io.println)",
 					"let add = (x, y) -> x + y with-doc \"Adds two numbers.\";\ndoc(add)"
 				]
 			}
@@ -5354,7 +5355,7 @@ function getMetaNormalExpression(normalExpressionReference, effectReference) {
 				examples: [
 					"arity(+)",
 					"arity(defined?)",
-					"arity(effect(dvala.random.int))",
+					"arity(@dvala.random.int)",
 					`
 let add = (x, y = 0) -> do
   x + y;
@@ -5764,7 +5765,7 @@ const doSpecialExpression = {
 	arity: {},
 	docs: {
 		category: "special-expression",
-		customVariants: ["do body end", "do body with case effect(name) then handler end"],
+		customVariants: ["do body end", "do body with case @name then handler end"],
 		details: [
 			[
 				"body",
@@ -5772,7 +5773,7 @@ const doSpecialExpression = {
 				"The expressions to evaluate."
 			],
 			[
-				"effect(name)",
+				"@name",
 				"expression",
 				"An expression evaluating to an effect value."
 			],
@@ -5790,9 +5791,9 @@ do
   b(a)
 end`, `
 do
-  perform(effect(dvala.io.println), "hello")
+  perform(@dvala.io.println, "hello")
 with
-  case effect(dvala.io.println) then ([msg]) -> null
+  case @dvala.io.println then ([msg]) -> null
 end`]
 	},
 	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => {
@@ -6109,7 +6110,7 @@ const doseqSpecialExpression = {
 		returns: { type: "null" },
 		description: "Iterates over `bindings`, evaluates `body` for each `binding` and returns `null`. This is useful for side effects.",
 		examples: [`
-doseq (i in [1, 2, 3]) -> perform(effect(dvala.io.println), i * 2)
+doseq (i in [1, 2, 3]) -> perform(@dvala.io.println, i * 2)
       `]
 	},
 	getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin }) => analyze(node, contextStack, getUndefinedSymbols, builtin)
@@ -6280,14 +6281,14 @@ const effectSpecialExpression = {
 	arity: {},
 	docs: {
 		category: "special-expression",
-		customVariants: ["effect(name)"],
+		customVariants: ["@name"],
 		details: [[
 			"name",
 			"dotted identifier",
 			"The effect name, e.g. `llm.complete` or `dvala.io.println`."
 		]],
 		description: "Returns the unique effect reference for the given name. Calling `effect` with the same name always returns the same reference. Effect references are first-class values that can be stored, passed, and compared with `==`.",
-		examples: ["effect(dvala.io.println)", "==(effect(llm.complete), effect(llm.complete))"],
+		examples: ["@dvala.io.println", "==(@llm.complete, @llm.complete)"],
 		seeAlso: ["effect?"]
 	},
 	getUndefinedSymbols: () => /* @__PURE__ */ new Set()
@@ -6379,7 +6380,7 @@ const performSpecialExpression = {
 		details: [[
 			"eff",
 			"expression",
-			"An expression evaluating to an effect value (from `effect(name)`)."
+			"An expression evaluating to an effect value (from `@name`)."
 		], [
 			"arg1, arg2, ...",
 			"expressions",
@@ -6388,9 +6389,9 @@ const performSpecialExpression = {
 		description: "Invokes an effect. The nearest enclosing `do/with` handler matching the effect intercepts the call. The handler receives the arguments as an array and its return value becomes the result of `perform`. If no local handler matches, the effect is dispatched to the host.",
 		examples: [`
 do
-  perform(effect(dvala.io.println), "hello")
+  perform(@dvala.io.println, "hello")
 with
-  case effect(dvala.io.println) then ([msg]) -> msg
+  case @dvala.io.println then ([msg]) -> msg
 end
 `],
 		seeAlso: ["effect?"]
@@ -6481,7 +6482,7 @@ function isFunctionDocs(docs) {
 }
 //#endregion
 //#region src/builtin/modules/assertion/assertion.dvala
-var assertion_default = "{\n  assert-fails: (fn, ...args) -> do\n    let message = first(args);\n    assert(function?(fn), \"First argument must be a function\");\n    if not(null?(message)) then assert(string?(message), \"Second argument must be a string\") end;\n    let failed-sentinel = effect(dvala.assertion.failed);\n    let result = do fn() with case effect(dvala.error) then ([msg]) -> failed-sentinel end;\n    if effect?(result) && result == failed-sentinel then\n      null\n    else\n      assert(false, message ?? \"Expected function to fail\")\n    end\n  end,\n\n  assert-fails-with: (fn, expected-error, ...args) -> do\n    let message = first(args);\n    assert(function?(fn), \"First argument must be a function\");\n    assert(string?(expected-error), \"Second argument must be a string\");\n    if not(null?(message)) then assert(string?(message), \"Third argument must be a string\") end;\n    let failed-sentinel = effect(dvala.assertion.failed);\n    let result = do fn() with case effect(dvala.error) then ([msg]) -> [failed-sentinel, msg] end;\n    if array?(result) && first(result) == failed-sentinel then do\n      let actual-error = second(result);\n      if actual-error == expected-error then\n        null\n      else\n        assert(false, message ?? (\"Expected function to fail with \\\"\" ++ expected-error ++ \"\\\" but got \\\"\" ++ actual-error ++ \"\\\"\"))\n      end\n    end\n    else\n      assert(false, message ?? (\"Expected function to fail with \\\"\" ++ expected-error ++ \"\\\"\"))\n    end\n  end,\n\n  assert-succeeds: (fn, ...args) -> do\n    let message = first(args);\n    assert(function?(fn), \"First argument must be a function\");\n    if not(null?(message)) then assert(string?(message), \"Second argument must be a string\") end;\n    let failed-sentinel = effect(dvala.assertion.failed);\n    let result = do fn() with case effect(dvala.error) then ([msg]) -> failed-sentinel end;\n    if effect?(result) && result == failed-sentinel then\n      assert(false, message ?? \"Expected function to succeed\")\n    else\n      null\n    end\n  end\n}\n";
+var assertion_default = "{\n  assert-fails: (fn, ...args) -> do\n    let message = first(args);\n    assert(function?(fn), \"First argument must be a function\");\n    if not(null?(message)) then assert(string?(message), \"Second argument must be a string\") end;\n    let failed-sentinel = @dvala.assertion.failed;\n    let result = do fn() with case @dvala.error then ([msg]) -> failed-sentinel end;\n    if effect?(result) && result == failed-sentinel then\n      null\n    else\n      assert(false, message ?? \"Expected function to fail\")\n    end\n  end,\n\n  assert-fails-with: (fn, expected-error, ...args) -> do\n    let message = first(args);\n    assert(function?(fn), \"First argument must be a function\");\n    assert(string?(expected-error), \"Second argument must be a string\");\n    if not(null?(message)) then assert(string?(message), \"Third argument must be a string\") end;\n    let failed-sentinel = @dvala.assertion.failed;\n    let result = do fn() with case @dvala.error then ([msg]) -> [failed-sentinel, msg] end;\n    if array?(result) && first(result) == failed-sentinel then do\n      let actual-error = second(result);\n      if actual-error == expected-error then\n        null\n      else\n        assert(false, message ?? (\"Expected function to fail with \\\"\" ++ expected-error ++ \"\\\" but got \\\"\" ++ actual-error ++ \"\\\"\"))\n      end\n    end\n    else\n      assert(false, message ?? (\"Expected function to fail with \\\"\" ++ expected-error ++ \"\\\"\"))\n    end\n  end,\n\n  assert-succeeds: (fn, ...args) -> do\n    let message = first(args);\n    assert(function?(fn), \"First argument must be a function\");\n    if not(null?(message)) then assert(string?(message), \"Second argument must be a string\") end;\n    let failed-sentinel = @dvala.assertion.failed;\n    let result = do fn() with case @dvala.error then ([msg]) -> failed-sentinel end;\n    if effect?(result) && result == failed-sentinel then\n      assert(false, message ?? \"Expected function to succeed\")\n    else\n      null\n    end\n  end\n}\n";
 //#endregion
 //#region src/builtin/modules/assertion/docs.ts
 const moduleDocs$5 = {
@@ -6500,10 +6501,10 @@ const moduleDocs$5 = {
 			"message"
 		] }],
 		examples: [
-			"let { assert!= } = import(assertion);\ndo assert!=(0, 0, \"Expected different values\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert!= } = import(assertion);\ndo assert!=(0, 0) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert!= } = import(assertion);\ndo 0 assert!= 0 with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert!= } = import(assertion);\ndo assert!=(0, 1) with case effect(dvala.error) then ([msg]) -> msg end"
+			"let { assert!= } = import(assertion);\ndo assert!=(0, 0, \"Expected different values\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert!= } = import(assertion);\ndo assert!=(0, 0) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert!= } = import(assertion);\ndo 0 assert!= 0 with case @dvala.error then ([msg]) -> msg end",
+			"let { assert!= } = import(assertion);\ndo assert!=(0, 1) with case @dvala.error then ([msg]) -> msg end"
 		],
 		seeAlso: ["assertion.assert="],
 		hideOperatorForm: true
@@ -6523,9 +6524,9 @@ const moduleDocs$5 = {
 			"message"
 		] }],
 		examples: [
-			"let { assert= } = import(assertion);\ndo assert=({ \"a\": 1 }, { \"a\": 2 }, \"Expected equal values\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert= } = import(assertion);\ndo assert=({ \"a\": 1 }, { \"a\": 2 }) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert= } = import(assertion);\ndo assert=({ \"a\": 1 }, { \"a\": 1 }) with case effect(dvala.error) then ([msg]) -> msg end"
+			"let { assert= } = import(assertion);\ndo assert=({ \"a\": 1 }, { \"a\": 2 }, \"Expected equal values\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert= } = import(assertion);\ndo assert=({ \"a\": 1 }, { \"a\": 2 }) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert= } = import(assertion);\ndo assert=({ \"a\": 1 }, { \"a\": 1 }) with case @dvala.error then ([msg]) -> msg end"
 		],
 		seeAlso: ["assertion.assert!="],
 		hideOperatorForm: true
@@ -6545,9 +6546,9 @@ const moduleDocs$5 = {
 			"message"
 		] }],
 		examples: [
-			"let { assert-gt } = import(assertion);\ndo assert-gt(0, 1, \"Expected greater value\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-gt } = import(assertion);\ndo assert-gt(0, 0) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-gt } = import(assertion);\ndo assert-gt(1, 0) with case effect(dvala.error) then ([msg]) -> msg end"
+			"let { assert-gt } = import(assertion);\ndo assert-gt(0, 1, \"Expected greater value\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-gt } = import(assertion);\ndo assert-gt(0, 0) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-gt } = import(assertion);\ndo assert-gt(1, 0) with case @dvala.error then ([msg]) -> msg end"
 		],
 		seeAlso: [
 			"assertion.assert-lt",
@@ -6571,9 +6572,9 @@ const moduleDocs$5 = {
 			"message"
 		] }],
 		examples: [
-			"let { assert-lt } = import(assertion);\ndo assert-lt(1, 0, \"Expected smaller value value\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-lt } = import(assertion);\ndo assert-lt(1, 1) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-lt } = import(assertion);\ndo assert-lt(0, 1) with case effect(dvala.error) then ([msg]) -> msg end"
+			"let { assert-lt } = import(assertion);\ndo assert-lt(1, 0, \"Expected smaller value value\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-lt } = import(assertion);\ndo assert-lt(1, 1) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-lt } = import(assertion);\ndo assert-lt(0, 1) with case @dvala.error then ([msg]) -> msg end"
 		],
 		seeAlso: [
 			"assertion.assert-gt",
@@ -6597,9 +6598,9 @@ const moduleDocs$5 = {
 			"message"
 		] }],
 		examples: [
-			"let { assert-gte } = import(assertion);\ndo assert-gte(0, 1, \"Expected greater value\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-gte } = import(assertion);\ndo assert-gte(0, 1) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-gte } = import(assertion);\ndo assert-gte(1, 1) with case effect(dvala.error) then ([msg]) -> msg end"
+			"let { assert-gte } = import(assertion);\ndo assert-gte(0, 1, \"Expected greater value\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-gte } = import(assertion);\ndo assert-gte(0, 1) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-gte } = import(assertion);\ndo assert-gte(1, 1) with case @dvala.error then ([msg]) -> msg end"
 		],
 		seeAlso: [
 			"assertion.assert-lte",
@@ -6623,9 +6624,9 @@ const moduleDocs$5 = {
 			"message"
 		] }],
 		examples: [
-			"let { assert-lte } = import(assertion);\ndo assert-lte(1, 0, \"Expected smaller value value\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-lte } = import(assertion);\ndo assert-lte(1, 0) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-lte } = import(assertion);\ndo assert-lte(1, 1) with case effect(dvala.error) then ([msg]) -> msg end"
+			"let { assert-lte } = import(assertion);\ndo assert-lte(1, 0, \"Expected smaller value value\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-lte } = import(assertion);\ndo assert-lte(1, 0) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-lte } = import(assertion);\ndo assert-lte(1, 1) with case @dvala.error then ([msg]) -> msg end"
 		],
 		seeAlso: [
 			"assertion.assert-gte",
@@ -6644,9 +6645,9 @@ const moduleDocs$5 = {
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
 		examples: [
-			"let { assert-true } = import(assertion);\ndo assert-true(false, \"Expected true\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-true } = import(assertion);\ndo assert-true(false) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-true } = import(assertion);\ndo assert-true(true) with case effect(dvala.error) then ([msg]) -> msg end"
+			"let { assert-true } = import(assertion);\ndo assert-true(false, \"Expected true\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-true } = import(assertion);\ndo assert-true(false) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-true } = import(assertion);\ndo assert-true(true) with case @dvala.error then ([msg]) -> msg end"
 		],
 		seeAlso: [
 			"assertion.assert-false",
@@ -6667,9 +6668,9 @@ const moduleDocs$5 = {
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
 		examples: [
-			"let { assert-false } = import(assertion);\ndo assert-false(true, \"Expected false\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-false } = import(assertion);\ndo assert-false(true) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-false } = import(assertion);\ndo assert-false(false) with case effect(dvala.error) then ([msg]) -> msg end"
+			"let { assert-false } = import(assertion);\ndo assert-false(true, \"Expected false\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-false } = import(assertion);\ndo assert-false(true) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-false } = import(assertion);\ndo assert-false(false) with case @dvala.error then ([msg]) -> msg end"
 		],
 		seeAlso: [
 			"assertion.assert-true",
@@ -6689,16 +6690,16 @@ const moduleDocs$5 = {
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
 		examples: [
-			"let { assert-truthy } = import(assertion);\ndo assert-truthy(false, \"Expected truthy\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-truthy } = import(assertion);\ndo assert-truthy(false) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-truthy } = import(assertion);\ndo assert-truthy(0) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-truthy } = import(assertion);\ndo assert-truthy(null) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-truthy } = import(assertion);\ndo assert-truthy(\"\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-truthy } = import(assertion);\ndo assert-truthy(true) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-truthy } = import(assertion);\ndo assert-truthy(1) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-truthy } = import(assertion);\ndo assert-truthy(\"x\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-truthy } = import(assertion);\ndo assert-truthy([]) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-truthy } = import(assertion);\ndo assert-truthy(nd) with case effect(dvala.error) then ([msg]) -> msg end"
+			"let { assert-truthy } = import(assertion);\ndo assert-truthy(false, \"Expected truthy\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-truthy } = import(assertion);\ndo assert-truthy(false) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-truthy } = import(assertion);\ndo assert-truthy(0) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-truthy } = import(assertion);\ndo assert-truthy(null) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-truthy } = import(assertion);\ndo assert-truthy(\"\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-truthy } = import(assertion);\ndo assert-truthy(true) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-truthy } = import(assertion);\ndo assert-truthy(1) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-truthy } = import(assertion);\ndo assert-truthy(\"x\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-truthy } = import(assertion);\ndo assert-truthy([]) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-truthy } = import(assertion);\ndo assert-truthy(nd) with case @dvala.error then ([msg]) -> msg end"
 		],
 		seeAlso: [
 			"assertion.assert-falsy",
@@ -6719,15 +6720,15 @@ const moduleDocs$5 = {
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
 		examples: [
-			"let { assert-falsy } = import(assertion);\ndo assert-falsy(true, \"Expected falsy\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-falsy } = import(assertion);\ndo assert-falsy(\"x\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-falsy } = import(assertion);\ndo assert-falsy([]) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-falsy } = import(assertion);\ndo assert-falsy(nd) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-falsy } = import(assertion);\ndo assert-falsy(1) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-falsy } = import(assertion);\ndo assert-falsy(false) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-falsy } = import(assertion);\ndo assert-falsy(0) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-falsy } = import(assertion);\ndo assert-falsy(null) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-falsy } = import(assertion);\ndo assert-falsy(\"\") with case effect(dvala.error) then ([msg]) -> msg end"
+			"let { assert-falsy } = import(assertion);\ndo assert-falsy(true, \"Expected falsy\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-falsy } = import(assertion);\ndo assert-falsy(\"x\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-falsy } = import(assertion);\ndo assert-falsy([]) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-falsy } = import(assertion);\ndo assert-falsy(nd) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-falsy } = import(assertion);\ndo assert-falsy(1) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-falsy } = import(assertion);\ndo assert-falsy(false) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-falsy } = import(assertion);\ndo assert-falsy(0) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-falsy } = import(assertion);\ndo assert-falsy(null) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-falsy } = import(assertion);\ndo assert-falsy(\"\") with case @dvala.error then ([msg]) -> msg end"
 		],
 		seeAlso: [
 			"assertion.assert-truthy",
@@ -6747,15 +6748,15 @@ const moduleDocs$5 = {
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
 		examples: [
-			"let { assert-null } = import(assertion);\ndo assert-null(null) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-null } = import(assertion);\ndo assert-null(true, \"Expected null\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-null } = import(assertion);\ndo assert-null(\"x\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-null } = import(assertion);\ndo assert-null([]) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-null } = import(assertion);\ndo assert-null(nd) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-null } = import(assertion);\ndo assert-null(1) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-null } = import(assertion);\ndo assert-null(false) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-null } = import(assertion);\ndo assert-null(0) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-null } = import(assertion);\ndo assert-null(\"\") with case effect(dvala.error) then ([msg]) -> msg end"
+			"let { assert-null } = import(assertion);\ndo assert-null(null) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-null } = import(assertion);\ndo assert-null(true, \"Expected null\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-null } = import(assertion);\ndo assert-null(\"x\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-null } = import(assertion);\ndo assert-null([]) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-null } = import(assertion);\ndo assert-null(nd) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-null } = import(assertion);\ndo assert-null(1) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-null } = import(assertion);\ndo assert-null(false) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-null } = import(assertion);\ndo assert-null(0) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-null } = import(assertion);\ndo assert-null(\"\") with case @dvala.error then ([msg]) -> msg end"
 		],
 		seeAlso: ["assertion.assert-truthy", "assertion.assert-falsy"],
 		hideOperatorForm: true
@@ -6769,7 +6770,7 @@ const moduleDocs$5 = {
 			message: { type: "string" }
 		},
 		variants: [{ argumentNames: ["fun"] }, { argumentNames: ["fun", "message"] }],
-		examples: ["let { assert-fails } = import(assertion);\nassert-fails(-> perform(effect(dvala.error), \"Error\"))", "let { assert-fails } = import(assertion);\ndo assert-fails(-> identity(\"Error\")) with case effect(dvala.error) then ([msg]) -> msg end"],
+		examples: ["let { assert-fails } = import(assertion);\nassert-fails(-> perform(@dvala.error, \"Error\"))", "let { assert-fails } = import(assertion);\ndo assert-fails(-> identity(\"Error\")) with case @dvala.error then ([msg]) -> msg end"],
 		seeAlso: ["assertion.assert-fails-with", "assertion.assert-succeeds"],
 		hideOperatorForm: true
 	},
@@ -6787,7 +6788,7 @@ const moduleDocs$5 = {
 			"error-message",
 			"message"
 		] }],
-		examples: ["let { assert-fails-with } = import(assertion);\ndo assert-fails-with(-> perform(effect(dvala.error), \"Error\"), \"Error\") with case effect(dvala.error) then ([msg]) -> msg end", "let { assert-fails-with } = import(assertion);\ndo assert-fails-with(-> identity(\"Error\"), \"Error\") with case effect(dvala.error) then ([msg]) -> msg end"],
+		examples: ["let { assert-fails-with } = import(assertion);\ndo assert-fails-with(-> perform(@dvala.error, \"Error\"), \"Error\") with case @dvala.error then ([msg]) -> msg end", "let { assert-fails-with } = import(assertion);\ndo assert-fails-with(-> identity(\"Error\"), \"Error\") with case @dvala.error then ([msg]) -> msg end"],
 		seeAlso: ["assertion.assert-fails", "assertion.assert-succeeds"],
 		hideOperatorForm: true
 	},
@@ -6800,7 +6801,7 @@ const moduleDocs$5 = {
 			message: { type: "string" }
 		},
 		variants: [{ argumentNames: ["fun"] }, { argumentNames: ["fun", "message"] }],
-		examples: ["let { assert-succeeds } = import(assertion);\ndo assert-succeeds(-> identity(\"OK\")) with case effect(dvala.error) then ([msg]) -> msg end", "let { assert-succeeds } = import(assertion);\ndo assert-succeeds(-> perform(effect(dvala.error), \"Error\")) with case effect(dvala.error) then ([msg]) -> msg end"],
+		examples: ["let { assert-succeeds } = import(assertion);\ndo assert-succeeds(-> identity(\"OK\")) with case @dvala.error then ([msg]) -> msg end", "let { assert-succeeds } = import(assertion);\ndo assert-succeeds(-> perform(@dvala.error, \"Error\")) with case @dvala.error then ([msg]) -> msg end"],
 		seeAlso: ["assertion.assert-fails", "assertion.assert-fails-with"],
 		hideOperatorForm: true
 	},
@@ -6814,9 +6815,9 @@ const moduleDocs$5 = {
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
 		examples: [
-			"let { assert-array } = import(assertion);\ndo assert-array([1, 2, 3]) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-array } = import(assertion);\ndo assert-array(\"string\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-array } = import(assertion);\ndo assert-array(42, \"Expected an array\") with case effect(dvala.error) then ([msg]) -> msg end"
+			"let { assert-array } = import(assertion);\ndo assert-array([1, 2, 3]) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-array } = import(assertion);\ndo assert-array(\"string\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-array } = import(assertion);\ndo assert-array(42, \"Expected an array\") with case @dvala.error then ([msg]) -> msg end"
 		],
 		seeAlso: [
 			"assertion.assert-object",
@@ -6835,9 +6836,9 @@ const moduleDocs$5 = {
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
 		examples: [
-			"let { assert-boolean } = import(assertion);\ndo assert-boolean(true) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-boolean } = import(assertion);\ndo assert-boolean(false) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-boolean } = import(assertion);\ndo assert-boolean(1, \"Expected a boolean\") with case effect(dvala.error) then ([msg]) -> msg end"
+			"let { assert-boolean } = import(assertion);\ndo assert-boolean(true) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-boolean } = import(assertion);\ndo assert-boolean(false) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-boolean } = import(assertion);\ndo assert-boolean(1, \"Expected a boolean\") with case @dvala.error then ([msg]) -> msg end"
 		],
 		seeAlso: [
 			"assertion.assert-true",
@@ -6857,10 +6858,10 @@ const moduleDocs$5 = {
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
 		examples: [
-			"let { assert-collection } = import(assertion);\ndo assert-collection([1, 2]) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-collection } = import(assertion);\ndo assert-collection({ a: 1 }) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-collection } = import(assertion);\ndo assert-collection(\"hello\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-collection } = import(assertion);\ndo assert-collection(42, \"Expected a collection\") with case effect(dvala.error) then ([msg]) -> msg end"
+			"let { assert-collection } = import(assertion);\ndo assert-collection([1, 2]) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-collection } = import(assertion);\ndo assert-collection({ a: 1 }) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-collection } = import(assertion);\ndo assert-collection(\"hello\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-collection } = import(assertion);\ndo assert-collection(42, \"Expected a collection\") with case @dvala.error then ([msg]) -> msg end"
 		],
 		seeAlso: [
 			"assertion.assert-sequence",
@@ -6878,7 +6879,7 @@ const moduleDocs$5 = {
 			message: { type: "string" }
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
-		examples: ["let { assert-function } = import(assertion);\ndo assert-function(-> $ + 1) with case effect(dvala.error) then ([msg]) -> msg end", "let { assert-function } = import(assertion);\ndo assert-function(42, \"Expected a function\") with case effect(dvala.error) then ([msg]) -> msg end"],
+		examples: ["let { assert-function } = import(assertion);\ndo assert-function(-> $ + 1) with case @dvala.error then ([msg]) -> msg end", "let { assert-function } = import(assertion);\ndo assert-function(42, \"Expected a function\") with case @dvala.error then ([msg]) -> msg end"],
 		seeAlso: ["assertion.assert-number", "assertion.assert-string"],
 		hideOperatorForm: true
 	},
@@ -6891,7 +6892,7 @@ const moduleDocs$5 = {
 			message: { type: "string" }
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
-		examples: ["let { assert-grid } = import(assertion);\ndo assert-grid([[1, 2], [3, 4]]) with case effect(dvala.error) then ([msg]) -> msg end", "let { assert-grid } = import(assertion);\ndo assert-grid([1, 2], \"Expected a grid\") with case effect(dvala.error) then ([msg]) -> msg end"],
+		examples: ["let { assert-grid } = import(assertion);\ndo assert-grid([[1, 2], [3, 4]]) with case @dvala.error then ([msg]) -> msg end", "let { assert-grid } = import(assertion);\ndo assert-grid([1, 2], \"Expected a grid\") with case @dvala.error then ([msg]) -> msg end"],
 		seeAlso: ["assertion.assert-matrix", "assertion.assert-vector"],
 		hideOperatorForm: true
 	},
@@ -6904,7 +6905,7 @@ const moduleDocs$5 = {
 			message: { type: "string" }
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
-		examples: ["let { assert-integer } = import(assertion);\ndo assert-integer(42) with case effect(dvala.error) then ([msg]) -> msg end", "let { assert-integer } = import(assertion);\ndo assert-integer(3.14, \"Expected an integer\") with case effect(dvala.error) then ([msg]) -> msg end"],
+		examples: ["let { assert-integer } = import(assertion);\ndo assert-integer(42) with case @dvala.error then ([msg]) -> msg end", "let { assert-integer } = import(assertion);\ndo assert-integer(3.14, \"Expected an integer\") with case @dvala.error then ([msg]) -> msg end"],
 		seeAlso: ["assertion.assert-number"],
 		hideOperatorForm: true
 	},
@@ -6917,7 +6918,7 @@ const moduleDocs$5 = {
 			message: { type: "string" }
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
-		examples: ["let { assert-matrix } = import(assertion);\ndo assert-matrix([[1, 2], [3, 4]]) with case effect(dvala.error) then ([msg]) -> msg end", "let { assert-matrix } = import(assertion);\ndo assert-matrix([1, 2], \"Expected a matrix\") with case effect(dvala.error) then ([msg]) -> msg end"],
+		examples: ["let { assert-matrix } = import(assertion);\ndo assert-matrix([[1, 2], [3, 4]]) with case @dvala.error then ([msg]) -> msg end", "let { assert-matrix } = import(assertion);\ndo assert-matrix([1, 2], \"Expected a matrix\") with case @dvala.error then ([msg]) -> msg end"],
 		seeAlso: ["assertion.assert-vector", "assertion.assert-grid"],
 		hideOperatorForm: true
 	},
@@ -6930,7 +6931,7 @@ const moduleDocs$5 = {
 			message: { type: "string" }
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
-		examples: ["let { assert-number } = import(assertion);\ndo assert-number(42) with case effect(dvala.error) then ([msg]) -> msg end", "let { assert-number } = import(assertion);\ndo assert-number(\"hello\", \"Expected a number\") with case effect(dvala.error) then ([msg]) -> msg end"],
+		examples: ["let { assert-number } = import(assertion);\ndo assert-number(42) with case @dvala.error then ([msg]) -> msg end", "let { assert-number } = import(assertion);\ndo assert-number(\"hello\", \"Expected a number\") with case @dvala.error then ([msg]) -> msg end"],
 		seeAlso: [
 			"assertion.assert-integer",
 			"assertion.assert-boolean",
@@ -6948,7 +6949,7 @@ const moduleDocs$5 = {
 			message: { type: "string" }
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
-		examples: ["let { assert-object } = import(assertion);\ndo assert-object({ a: 1 }) with case effect(dvala.error) then ([msg]) -> msg end", "let { assert-object } = import(assertion);\ndo assert-object([1, 2], \"Expected an object\") with case effect(dvala.error) then ([msg]) -> msg end"],
+		examples: ["let { assert-object } = import(assertion);\ndo assert-object({ a: 1 }) with case @dvala.error then ([msg]) -> msg end", "let { assert-object } = import(assertion);\ndo assert-object([1, 2], \"Expected an object\") with case @dvala.error then ([msg]) -> msg end"],
 		seeAlso: ["assertion.assert-array", "assertion.assert-collection"],
 		hideOperatorForm: true
 	},
@@ -6961,7 +6962,7 @@ const moduleDocs$5 = {
 			message: { type: "string" }
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
-		examples: ["let { assert-regexp } = import(assertion);\ndo assert-regexp(#\"^start\") with case effect(dvala.error) then ([msg]) -> msg end", "let { assert-regexp } = import(assertion);\ndo assert-regexp(\"hello\", \"Expected a regexp\") with case effect(dvala.error) then ([msg]) -> msg end"],
+		examples: ["let { assert-regexp } = import(assertion);\ndo assert-regexp(#\"^start\") with case @dvala.error then ([msg]) -> msg end", "let { assert-regexp } = import(assertion);\ndo assert-regexp(\"hello\", \"Expected a regexp\") with case @dvala.error then ([msg]) -> msg end"],
 		seeAlso: ["assertion.assert-string"],
 		hideOperatorForm: true
 	},
@@ -6975,9 +6976,9 @@ const moduleDocs$5 = {
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
 		examples: [
-			"let { assert-sequence } = import(assertion);\ndo assert-sequence([1, 2]) with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-sequence } = import(assertion);\ndo assert-sequence(\"hello\") with case effect(dvala.error) then ([msg]) -> msg end",
-			"let { assert-sequence } = import(assertion);\ndo assert-sequence({ a: 1 }, \"Expected a sequence\") with case effect(dvala.error) then ([msg]) -> msg end"
+			"let { assert-sequence } = import(assertion);\ndo assert-sequence([1, 2]) with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-sequence } = import(assertion);\ndo assert-sequence(\"hello\") with case @dvala.error then ([msg]) -> msg end",
+			"let { assert-sequence } = import(assertion);\ndo assert-sequence({ a: 1 }, \"Expected a sequence\") with case @dvala.error then ([msg]) -> msg end"
 		],
 		seeAlso: ["assertion.assert-collection", "assertion.assert-array"],
 		hideOperatorForm: true
@@ -6991,7 +6992,7 @@ const moduleDocs$5 = {
 			message: { type: "string" }
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
-		examples: ["let { assert-string } = import(assertion);\ndo assert-string(\"hello\") with case effect(dvala.error) then ([msg]) -> msg end", "let { assert-string } = import(assertion);\ndo assert-string(42, \"Expected a string\") with case effect(dvala.error) then ([msg]) -> msg end"],
+		examples: ["let { assert-string } = import(assertion);\ndo assert-string(\"hello\") with case @dvala.error then ([msg]) -> msg end", "let { assert-string } = import(assertion);\ndo assert-string(42, \"Expected a string\") with case @dvala.error then ([msg]) -> msg end"],
 		seeAlso: [
 			"assertion.assert-number",
 			"assertion.assert-boolean",
@@ -7009,7 +7010,7 @@ const moduleDocs$5 = {
 			message: { type: "string" }
 		},
 		variants: [{ argumentNames: ["value"] }, { argumentNames: ["value", "message"] }],
-		examples: ["let { assert-vector } = import(assertion);\ndo assert-vector([1, 2, 3]) with case effect(dvala.error) then ([msg]) -> msg end", "let { assert-vector } = import(assertion);\ndo assert-vector([\"a\", \"b\"], \"Expected a vector\") with case effect(dvala.error) then ([msg]) -> msg end"],
+		examples: ["let { assert-vector } = import(assertion);\ndo assert-vector([1, 2, 3]) with case @dvala.error then ([msg]) -> msg end", "let { assert-vector } = import(assertion);\ndo assert-vector([\"a\", \"b\"], \"Expected a vector\") with case @dvala.error then ([msg]) -> msg end"],
 		seeAlso: ["assertion.assert-matrix", "assertion.assert-grid"],
 		hideOperatorForm: true
 	}
@@ -7617,7 +7618,7 @@ const bitwiseUtilsModule = {
 };
 //#endregion
 //#region src/builtin/modules/collection/collection.dvala
-var collection_default$1 = "{\n  update: (coll, key, fn, ...extra-params) ->\n    assoc(coll, key, apply(fn, [get(coll, key), ...extra-params])),\n\n  update-in: (coll, ks, fn, ...extra-params) -> do\n    let k = first(ks);\n    if count(ks) == 1 then\n      assoc(coll, k, apply(fn, [get(coll, k), ...extra-params]))\n    else\n      let inner = get(coll, k);\n      let inner-coll = null?(inner) ? {} : inner;\n      assoc(coll, k, apply(self, [inner-coll, slice(ks, 1), fn, ...extra-params]))\n    end\n  end,\n\n  filteri: (coll, fn) -> do\n    cond\n      case array?(coll) then\n        reduce(\n          for (i in range(count(coll))) -> [nth(coll, i), i],\n          (acc, pair) -> if fn(first(pair), second(pair)) then [...acc, first(pair)] else acc end,\n          []\n        )\n\n      case string?(coll) then\n        reduce(\n          for (i in range(count(coll))) -> [nth(coll, i), i],\n          (acc, pair) -> if fn(first(pair), second(pair)) then ++(acc, first(pair)) else acc end,\n          \"\"\n        )\n\n      case object?(coll) then\n        reduce(keys(coll), (acc, k) ->\n          if fn(coll(k), k) then assoc(acc, k, coll(k)) else acc end,\n          {}\n        )\n\n      case true then\n        perform(effect(dvala.error), \"Expected collection\")\n    end\n  end,\n\n  mapi: (coll, fn) -> do\n    cond\n      case array?(coll) then\n        for (i in range(count(coll))) -> fn(nth(coll, i), i)\n\n      case string?(coll) then\n        reduce(\n          for (i in range(count(coll))) -> fn(nth(coll, i), i),\n          (acc, ch) -> ++(acc, ch),\n          \"\"\n        )\n\n      case object?(coll) then\n        reduce(keys(coll), (acc, k) ->\n          assoc(acc, k, fn(coll(k), k)),\n          {}\n        )\n\n      case true then\n        perform(effect(dvala.error), \"Expected collection\")\n    end\n  end,\n\n  reducei: (coll, fn, initial) -> do\n    cond\n      case string?(coll) then\n        loop (acc = initial, i = 0) -> do\n          if i >= count(coll) then\n            acc\n          else\n            recur(fn(acc, nth(coll, i), i), i + 1)\n          end\n        end\n\n      case array?(coll) then\n        loop (acc = initial, i = 0) -> do\n          if i >= count(coll) then\n            acc\n          else\n            recur(fn(acc, nth(coll, i), i), i + 1)\n          end\n        end\n\n      case object?(coll) then\n        reduce(keys(coll), (acc, k) -> fn(acc, coll(k), k), initial)\n\n      case true then\n        perform(effect(dvala.error), \"Expected collection\")\n    end\n  end,\n\n  reduce-right: (coll, fn, initial) -> do\n    cond\n      case string?(coll) then\n        reduce(reverse(coll), fn, initial)\n\n      case array?(coll) then\n        reduce(reverse(coll), fn, initial)\n\n      case object?(coll) then\n        reduce(reverse(keys(coll)), (acc, k) -> fn(acc, coll(k)), initial)\n\n      case true then\n        perform(effect(dvala.error), \"Expected collection\")\n    end\n  end,\n\n  reducei-right: (coll, fn, initial) -> do\n    cond\n      case string?(coll) then\n        let len = count(coll);\n        loop (acc = initial, i = len - 1) -> do\n          if i < 0 then\n            acc\n          else\n            recur(fn(acc, nth(coll, i), i), i - 1)\n          end\n        end\n\n      case array?(coll) then\n        let len = count(coll);\n        loop (acc = initial, i = len - 1) -> do\n          if i < 0 then\n            acc\n          else\n            recur(fn(acc, nth(coll, i), i), i - 1)\n          end\n        end\n\n      case object?(coll) then\n        reduce(reverse(keys(coll)), (acc, k) -> fn(acc, coll(k), k), initial)\n\n      case true then\n        perform(effect(dvala.error), \"Expected collection\")\n    end\n  end,\n\n  reductions: (coll, fn, initial) -> do\n    let items = cond\n      case string?(coll) then\n        if count(coll) == 0 then [] else for (i in range(count(coll))) -> nth(coll, i) end\n\n      case array?(coll) then coll\n\n      case object?(coll) then\n        for (k in keys(coll)) -> coll(k)\n\n      case true then\n        perform(effect(dvala.error), \"Expected collection\")\n    end;\n    if count(items) == 0 then\n      [initial]\n    else\n      reduce(items, (acc, elem) -> do\n        let prev = last(acc);\n        [...acc, fn(prev, elem)]\n      end, [initial])\n    end\n  end,\n\n  reductionsi: (coll, fn, initial) -> do\n    cond\n      case string?(coll) then do\n        if count(coll) == 0 then\n          [initial]\n        else\n          reduce(\n            for (i in range(count(coll))) -> [nth(coll, i), i],\n            (acc, pair) -> do\n              let prev = last(acc);\n              [...acc, fn(prev, first(pair), second(pair))]\n            end,\n            [initial]\n          )\n        end\n      end\n\n      case array?(coll) then do\n        if count(coll) == 0 then\n          [initial]\n        else\n          reduce(\n            for (i in range(count(coll))) -> [nth(coll, i), i],\n            (acc, pair) -> do\n              let prev = last(acc);\n              [...acc, fn(prev, first(pair), second(pair))]\n            end,\n            [initial]\n          )\n        end\n      end\n\n      case object?(coll) then do\n        let ks = keys(coll);\n        if count(ks) == 0 then\n          [initial]\n        else\n          reduce(ks, (acc, k) -> do\n            let prev = last(acc);\n            [...acc, fn(prev, coll(k), k)]\n          end, [initial])\n        end\n      end\n\n      case true then\n        perform(effect(dvala.error), \"Expected collection\")\n    end\n  end,\n\n  \"every?\": (coll, fn) -> do\n    let items = cond\n      case array?(coll) then coll\n      case string?(coll) then for (i in range(count(coll))) -> nth(coll, i)\n      case object?(coll) then for (k in keys(coll)) -> [k, coll(k)]\n      case true then perform(effect(dvala.error), \"Expected collection\")\n    end;\n    loop (i = 0) ->\n      cond\n        case i >= count(items) then true\n        case not(fn(nth(items, i))) then false\n        case true then recur(i + 1)\n      end\n  end,\n\n  \"any?\": (coll, fn) -> do\n    let items = cond\n      case array?(coll) then coll\n      case string?(coll) then for (i in range(count(coll))) -> nth(coll, i)\n      case object?(coll) then for (k in keys(coll)) -> [k, coll(k)]\n      case true then perform(effect(dvala.error), \"Expected collection\")\n    end;\n    loop (i = 0) ->\n      cond\n        case i >= count(items) then false\n        case fn(nth(items, i)) then true\n        case true then recur(i + 1)\n      end\n  end,\n\n  \"not-any?\": (coll, fn) -> do\n    let items = cond\n      case array?(coll) then coll\n      case string?(coll) then for (i in range(count(coll))) -> nth(coll, i)\n      case object?(coll) then for (k in keys(coll)) -> [k, coll(k)]\n      case true then perform(effect(dvala.error), \"Expected collection\")\n    end;\n    loop (i = 0) ->\n      cond\n        case i >= count(items) then true\n        case fn(nth(items, i)) then false\n        case true then recur(i + 1)\n      end\n  end,\n\n  \"not-every?\": (coll, fn) -> do\n    let items = cond\n      case array?(coll) then coll\n      case string?(coll) then for (i in range(count(coll))) -> nth(coll, i)\n      case object?(coll) then for (k in keys(coll)) -> [k, coll(k)]\n      case true then perform(effect(dvala.error), \"Expected collection\")\n    end;\n    loop (i = 0) ->\n      cond\n        case i >= count(items) then false\n        case not(fn(nth(items, i))) then true\n        case true then recur(i + 1)\n      end\n  end\n}";
+var collection_default$1 = "{\n  update: (coll, key, fn, ...extra-params) ->\n    assoc(coll, key, apply(fn, [get(coll, key), ...extra-params])),\n\n  update-in: (coll, ks, fn, ...extra-params) -> do\n    let k = first(ks);\n    if count(ks) == 1 then\n      assoc(coll, k, apply(fn, [get(coll, k), ...extra-params]))\n    else\n      let inner = get(coll, k);\n      let inner-coll = null?(inner) ? {} : inner;\n      assoc(coll, k, apply(self, [inner-coll, slice(ks, 1), fn, ...extra-params]))\n    end\n  end,\n\n  filteri: (coll, fn) -> do\n    cond\n      case array?(coll) then\n        reduce(\n          for (i in range(count(coll))) -> [nth(coll, i), i],\n          (acc, pair) -> if fn(first(pair), second(pair)) then [...acc, first(pair)] else acc end,\n          []\n        )\n\n      case string?(coll) then\n        reduce(\n          for (i in range(count(coll))) -> [nth(coll, i), i],\n          (acc, pair) -> if fn(first(pair), second(pair)) then ++(acc, first(pair)) else acc end,\n          \"\"\n        )\n\n      case object?(coll) then\n        reduce(keys(coll), (acc, k) ->\n          if fn(coll(k), k) then assoc(acc, k, coll(k)) else acc end,\n          {}\n        )\n\n      case true then\n        perform(@dvala.error, \"Expected collection\")\n    end\n  end,\n\n  mapi: (coll, fn) -> do\n    cond\n      case array?(coll) then\n        for (i in range(count(coll))) -> fn(nth(coll, i), i)\n\n      case string?(coll) then\n        reduce(\n          for (i in range(count(coll))) -> fn(nth(coll, i), i),\n          (acc, ch) -> ++(acc, ch),\n          \"\"\n        )\n\n      case object?(coll) then\n        reduce(keys(coll), (acc, k) ->\n          assoc(acc, k, fn(coll(k), k)),\n          {}\n        )\n\n      case true then\n        perform(@dvala.error, \"Expected collection\")\n    end\n  end,\n\n  reducei: (coll, fn, initial) -> do\n    cond\n      case string?(coll) then\n        loop (acc = initial, i = 0) -> do\n          if i >= count(coll) then\n            acc\n          else\n            recur(fn(acc, nth(coll, i), i), i + 1)\n          end\n        end\n\n      case array?(coll) then\n        loop (acc = initial, i = 0) -> do\n          if i >= count(coll) then\n            acc\n          else\n            recur(fn(acc, nth(coll, i), i), i + 1)\n          end\n        end\n\n      case object?(coll) then\n        reduce(keys(coll), (acc, k) -> fn(acc, coll(k), k), initial)\n\n      case true then\n        perform(@dvala.error, \"Expected collection\")\n    end\n  end,\n\n  reduce-right: (coll, fn, initial) -> do\n    cond\n      case string?(coll) then\n        reduce(reverse(coll), fn, initial)\n\n      case array?(coll) then\n        reduce(reverse(coll), fn, initial)\n\n      case object?(coll) then\n        reduce(reverse(keys(coll)), (acc, k) -> fn(acc, coll(k)), initial)\n\n      case true then\n        perform(@dvala.error, \"Expected collection\")\n    end\n  end,\n\n  reducei-right: (coll, fn, initial) -> do\n    cond\n      case string?(coll) then\n        let len = count(coll);\n        loop (acc = initial, i = len - 1) -> do\n          if i < 0 then\n            acc\n          else\n            recur(fn(acc, nth(coll, i), i), i - 1)\n          end\n        end\n\n      case array?(coll) then\n        let len = count(coll);\n        loop (acc = initial, i = len - 1) -> do\n          if i < 0 then\n            acc\n          else\n            recur(fn(acc, nth(coll, i), i), i - 1)\n          end\n        end\n\n      case object?(coll) then\n        reduce(reverse(keys(coll)), (acc, k) -> fn(acc, coll(k), k), initial)\n\n      case true then\n        perform(@dvala.error, \"Expected collection\")\n    end\n  end,\n\n  reductions: (coll, fn, initial) -> do\n    let items = cond\n      case string?(coll) then\n        if count(coll) == 0 then [] else for (i in range(count(coll))) -> nth(coll, i) end\n\n      case array?(coll) then coll\n\n      case object?(coll) then\n        for (k in keys(coll)) -> coll(k)\n\n      case true then\n        perform(@dvala.error, \"Expected collection\")\n    end;\n    if count(items) == 0 then\n      [initial]\n    else\n      reduce(items, (acc, elem) -> do\n        let prev = last(acc);\n        [...acc, fn(prev, elem)]\n      end, [initial])\n    end\n  end,\n\n  reductionsi: (coll, fn, initial) -> do\n    cond\n      case string?(coll) then do\n        if count(coll) == 0 then\n          [initial]\n        else\n          reduce(\n            for (i in range(count(coll))) -> [nth(coll, i), i],\n            (acc, pair) -> do\n              let prev = last(acc);\n              [...acc, fn(prev, first(pair), second(pair))]\n            end,\n            [initial]\n          )\n        end\n      end\n\n      case array?(coll) then do\n        if count(coll) == 0 then\n          [initial]\n        else\n          reduce(\n            for (i in range(count(coll))) -> [nth(coll, i), i],\n            (acc, pair) -> do\n              let prev = last(acc);\n              [...acc, fn(prev, first(pair), second(pair))]\n            end,\n            [initial]\n          )\n        end\n      end\n\n      case object?(coll) then do\n        let ks = keys(coll);\n        if count(ks) == 0 then\n          [initial]\n        else\n          reduce(ks, (acc, k) -> do\n            let prev = last(acc);\n            [...acc, fn(prev, coll(k), k)]\n          end, [initial])\n        end\n      end\n\n      case true then\n        perform(@dvala.error, \"Expected collection\")\n    end\n  end,\n\n  \"every?\": (coll, fn) -> do\n    let items = cond\n      case array?(coll) then coll\n      case string?(coll) then for (i in range(count(coll))) -> nth(coll, i)\n      case object?(coll) then for (k in keys(coll)) -> [k, coll(k)]\n      case true then perform(@dvala.error, \"Expected collection\")\n    end;\n    loop (i = 0) ->\n      cond\n        case i >= count(items) then true\n        case not(fn(nth(items, i))) then false\n        case true then recur(i + 1)\n      end\n  end,\n\n  \"any?\": (coll, fn) -> do\n    let items = cond\n      case array?(coll) then coll\n      case string?(coll) then for (i in range(count(coll))) -> nth(coll, i)\n      case object?(coll) then for (k in keys(coll)) -> [k, coll(k)]\n      case true then perform(@dvala.error, \"Expected collection\")\n    end;\n    loop (i = 0) ->\n      cond\n        case i >= count(items) then false\n        case fn(nth(items, i)) then true\n        case true then recur(i + 1)\n      end\n  end,\n\n  \"not-any?\": (coll, fn) -> do\n    let items = cond\n      case array?(coll) then coll\n      case string?(coll) then for (i in range(count(coll))) -> nth(coll, i)\n      case object?(coll) then for (k in keys(coll)) -> [k, coll(k)]\n      case true then perform(@dvala.error, \"Expected collection\")\n    end;\n    loop (i = 0) ->\n      cond\n        case i >= count(items) then true\n        case fn(nth(items, i)) then false\n        case true then recur(i + 1)\n      end\n  end,\n\n  \"not-every?\": (coll, fn) -> do\n    let items = cond\n      case array?(coll) then coll\n      case string?(coll) then for (i in range(count(coll))) -> nth(coll, i)\n      case object?(coll) then for (k in keys(coll)) -> [k, coll(k)]\n      case true then perform(@dvala.error, \"Expected collection\")\n    end;\n    loop (i = 0) ->\n      cond\n        case i >= count(items) then false\n        case not(fn(nth(items, i))) then true\n        case true then recur(i + 1)\n      end\n  end\n}";
 //#endregion
 //#region src/builtin/modules/collection/index.ts
 function get(coll, key) {
@@ -24392,10 +24393,10 @@ const standardEffects = {
 			} },
 			variants: [{ argumentNames: ["value"] }],
 			examples: [{
-				code: "perform(effect(dvala.io.print), \"hello\")",
+				code: "perform(@dvala.io.print, \"hello\")",
 				noRun: true
 			}, {
-				code: "perform(effect(dvala.io.print), 42)",
+				code: "perform(@dvala.io.print, 42)",
 				noRun: true
 			}],
 			seeAlso: [
@@ -24420,10 +24421,10 @@ const standardEffects = {
 			} },
 			variants: [{ argumentNames: ["value"] }],
 			examples: [{
-				code: "perform(effect(dvala.io.println), \"hello\")",
+				code: "perform(@dvala.io.println, \"hello\")",
 				noRun: true
 			}, {
-				code: "perform(effect(dvala.io.println), [1, 2, 3])",
+				code: "perform(@dvala.io.println, [1, 2, 3])",
 				noRun: true
 			}],
 			seeAlso: [
@@ -24458,7 +24459,7 @@ const standardEffects = {
 			} },
 			variants: [{ argumentNames: ["value"] }],
 			examples: [{
-				code: "perform(effect(dvala.io.error), \"something went wrong\")",
+				code: "perform(@dvala.io.error, \"something went wrong\")",
 				noRun: true
 			}],
 			seeAlso: [
@@ -24492,7 +24493,7 @@ const standardEffects = {
 				description: "Optional prompt message to display."
 			} },
 			variants: [{ argumentNames: [] }, { argumentNames: ["message"] }],
-			examples: ["effect(dvala.io.read-line)"],
+			examples: ["@dvala.io.read-line"],
 			seeAlso: [
 				"-effect-dvala.io.read-stdin",
 				"-effect-dvala.io.print",
@@ -24570,7 +24571,7 @@ const standardEffects = {
 				}
 			},
 			variants: [{ argumentNames: ["items"] }, { argumentNames: ["items", "options"] }],
-			examples: ["effect(dvala.io.pick)"],
+			examples: ["@dvala.io.pick"],
 			seeAlso: [
 				"-effect-dvala.io.read-line",
 				"-effect-dvala.io.confirm",
@@ -24615,7 +24616,7 @@ const standardEffects = {
 				}
 			},
 			variants: [{ argumentNames: ["question"] }, { argumentNames: ["question", "options"] }],
-			examples: ["effect(dvala.io.confirm)"],
+			examples: ["@dvala.io.confirm"],
 			seeAlso: [
 				"-effect-dvala.io.read-line",
 				"-effect-dvala.io.pick",
@@ -24647,7 +24648,7 @@ const standardEffects = {
 			returns: { type: "string" },
 			args: {},
 			variants: [{ argumentNames: [] }],
-			examples: ["effect(dvala.io.read-stdin)"],
+			examples: ["@dvala.io.read-stdin"],
 			seeAlso: [
 				"-effect-dvala.io.read-line",
 				"perform",
@@ -24670,7 +24671,7 @@ const standardEffects = {
 			returns: { type: "number" },
 			args: {},
 			variants: [{ argumentNames: [] }],
-			examples: ["perform(effect(dvala.random))"],
+			examples: ["perform(@dvala.random)"],
 			seeAlso: [
 				"-effect-dvala.random.int",
 				"-effect-dvala.random.uuid",
@@ -24696,7 +24697,7 @@ const standardEffects = {
 			returns: { type: "string" },
 			args: {},
 			variants: [{ argumentNames: [] }],
-			examples: ["perform(effect(dvala.random.uuid))"],
+			examples: ["perform(@dvala.random.uuid)"],
 			seeAlso: [
 				"-effect-dvala.random",
 				"perform",
@@ -24733,7 +24734,7 @@ const standardEffects = {
 				}
 			},
 			variants: [{ argumentNames: ["min", "max"] }],
-			examples: ["perform(effect(dvala.random.int), 1, 100)"],
+			examples: ["perform(@dvala.random.int, 1, 100)"],
 			seeAlso: [
 				"-effect-dvala.random",
 				"-effect-dvala.random.item",
@@ -24763,7 +24764,7 @@ const standardEffects = {
 				description: "Non-empty array to pick from."
 			} },
 			variants: [{ argumentNames: ["array"] }],
-			examples: ["perform(effect(dvala.random.item), [\"a\", \"b\", \"c\"])"],
+			examples: ["perform(@dvala.random.item, [\"a\", \"b\", \"c\"])"],
 			seeAlso: [
 				"-effect-dvala.random",
 				"-effect-dvala.random.shuffle",
@@ -24800,7 +24801,7 @@ const standardEffects = {
 				description: "Array to shuffle."
 			} },
 			variants: [{ argumentNames: ["array"] }],
-			examples: ["perform(effect(dvala.random.shuffle), [1, 2, 3, 4, 5])"],
+			examples: ["perform(@dvala.random.shuffle, [1, 2, 3, 4, 5])"],
 			seeAlso: [
 				"-effect-dvala.random",
 				"-effect-dvala.random.item",
@@ -24824,7 +24825,7 @@ const standardEffects = {
 			returns: { type: "number" },
 			args: {},
 			variants: [{ argumentNames: [] }],
-			examples: ["perform(effect(dvala.time.now))"],
+			examples: ["perform(@dvala.time.now)"],
 			seeAlso: [
 				"-effect-dvala.time.zone",
 				"-effect-dvala.sleep",
@@ -24848,7 +24849,7 @@ const standardEffects = {
 			returns: { type: "string" },
 			args: {},
 			variants: [{ argumentNames: [] }],
-			examples: ["perform(effect(dvala.time.zone))"],
+			examples: ["perform(@dvala.time.zone)"],
 			seeAlso: [
 				"-effect-dvala.time.now",
 				"perform",
@@ -24876,7 +24877,7 @@ const standardEffects = {
 				}
 			},
 			variants: [{ argumentNames: ["message"] }, { argumentNames: ["message", "meta"] }],
-			examples: ["perform(effect(dvala.checkpoint), \"init\")", "perform(effect(dvala.checkpoint), \"analysis-done\", { step: 1 })"],
+			examples: ["perform(@dvala.checkpoint, \"init\")", "perform(@dvala.checkpoint, \"analysis-done\", { step: 1 })"],
 			seeAlso: ["perform", "effect"]
 		}
 	},
@@ -24902,7 +24903,7 @@ const standardEffects = {
 				description: "The number of milliseconds to sleep. Must be a non-negative number."
 			} },
 			variants: [{ argumentNames: ["ms"] }],
-			examples: ["effect(dvala.sleep)"],
+			examples: ["@dvala.sleep"],
 			seeAlso: [
 				"-effect-dvala.time.now",
 				"perform",
@@ -25148,7 +25149,7 @@ const datatype = {
 		title: "effect",
 		category: "datatype",
 		description: "An effect, created with the `effect` special expression. Effects are used with `perform` to trigger algebraic effects.",
-		examples: ["effect(dvala.io.println)", "effect(dvala.time.now)"]
+		examples: ["@dvala.io.println", "@dvala.time.now"]
 	},
 	"-type-never": {
 		datatype: true,
@@ -25156,8 +25157,8 @@ const datatype = {
 		category: "datatype",
 		description: "A value that can never be created",
 		examples: [`
-// perform(effect(dvala.error), "error") will never return a value
-do perform(effect(dvala.error), "error") with case effect(dvala.error) then (args) -> "never" end`]
+// perform(@dvala.error, "error") will never return a value
+do perform(@dvala.error, "error") with case @dvala.error then (args) -> "never" end`]
 	}
 };
 //#endregion
@@ -25575,6 +25576,7 @@ const illegalFirstSymbolCharacters = [
 	"7",
 	"8",
 	"9",
+	"@",
 	...illegalSymbolCharacters
 ];
 const illegalSymbolCharacterSet = new Set(illegalSymbolCharacters);
@@ -25740,6 +25742,34 @@ const tokenizeBasePrefixedNumber = (input, position) => {
 	if (nextChar && !postNumberRegExp.test(nextChar)) return NO_MATCH;
 	return [length, ["BasePrefixedNumber", input.substring(position, i)]];
 };
+/**
+* Tokenize effect name literal: @segment.segment.segment
+* Each segment follows symbol naming rules. Dots separate segments.
+* The token value is the name without the @ prefix.
+*/
+const tokenizeEffectName = (input, position) => {
+	if (input[position] !== "@") return NO_MATCH;
+	let i = position + 1;
+	const firstChar = input[i];
+	if (!firstChar || illegalFirstSymbolCharacterSet.has(firstChar)) return NO_MATCH;
+	let name = "";
+	while (i < input.length && !illegalSymbolCharacterSet.has(input[i])) {
+		name += input[i];
+		i++;
+	}
+	while (i < input.length && input[i] === ".") {
+		const dotPos = i;
+		i++;
+		const segStart = i;
+		if (i >= input.length || illegalFirstSymbolCharacterSet.has(input[i])) {
+			i = dotPos;
+			break;
+		}
+		while (i < input.length && !illegalSymbolCharacterSet.has(input[i])) i++;
+		name += `.${input.slice(segStart, i)}`;
+	}
+	return [i - position, ["EffectName", name]];
+};
 const tokenizeSymbol = (input, position) => {
 	let value = input[position];
 	if (value === "'") {
@@ -25945,6 +25975,7 @@ const tokenizers = [
 	tokenizeBasePrefixedNumber,
 	tokenizeNumber,
 	tokenizeOperator,
+	tokenizeEffectName,
 	tokenizeSymbol
 ];
 //#endregion
@@ -26771,6 +26802,7 @@ function findUnresolvedSymbolsInNode(node, contextStack, builtin) {
 			for (const segment of node[1]) findUnresolvedSymbolsInNode(segment, contextStack, builtin)?.forEach((symbol) => unresolvedSymbols.add(symbol));
 			return unresolvedSymbols;
 		}
+		case NodeTypes.EffectName: return null;
 		default: throw new DvalaError(`Unhandled node type: ${nodeType}`, node[2]);
 	}
 }
@@ -27947,6 +27979,9 @@ function parseOperandPart(ctx) {
 		}
 		case "ReservedSymbol": return parseReservedSymbol(ctx);
 		case "RegexpShorthand": return parseRegexpShorthand(ctx);
+		case "EffectName":
+			ctx.advance();
+			return withSourceCodeInfo([NodeTypes.EffectName, token[1]], token[2]);
 		default: throw new DvalaError(`Unknown token type: ${tokenType}`, token[2]);
 	}
 }
@@ -28766,6 +28801,11 @@ function stepNode(node, env, k) {
 		case NodeTypes.NormalExpression: return stepNormalExpression(node, env, k);
 		case NodeTypes.SpecialExpression: return stepSpecialExpression(node, env, k);
 		case NodeTypes.TemplateString: return stepTemplateString(node, env, k);
+		case NodeTypes.EffectName: return {
+			type: "Value",
+			value: getEffectRef(node[1]),
+			k
+		};
 		default: throw new DvalaError(`${getNodeTypeName(node[0])}-node cannot be evaluated`, node[2]);
 	}
 }
@@ -30593,7 +30633,7 @@ function applyPerformArgs(frame, value, k) {
 /**
 * Check if a handler's case clause matches the given effect.
 * Supports two forms:
-* - EffectRef: exact name match (`case effect(dvala.error)`)
+* - EffectRef: exact name match (`case @dvala.error`)
 * - Predicate function: called with the effect, truthy = match (`case my-predicate`)
 *
 * Predicate functions must be synchronous — async predicates throw an error.
@@ -32007,11 +32047,11 @@ async function runEffectLoop(initial, handlers, signal, initialSnapshotState, ma
 //#endregion
 //#region src/builtin/normalExpressions/initCoreDvala.ts
 const coreDvalaSources = {
-	collection: "{\n  map: (first-coll, ...args) -> do\n    let fn = last(args);\n    let other-colls = slice(args, 0, count(args) - 1);\n    let all-colls = [first-coll, ...other-colls];\n\n    cond\n      case object?(first-coll) then do\n        let expected-keys = keys(first-coll) |> sort;\n        doseq (obj in other-colls) -> do\n          if not(object?(obj)) then\n            perform(effect(dvala.error), \"Expected object\")\n          end;\n          let obj-keys = keys(obj) |> sort;\n          if not(obj-keys == expected-keys) then\n            perform(effect(dvala.error), ++(\n              \"All objects must have the same keys. Expected: \",\n              join(expected-keys, \", \"),\n              \". Found: \",\n              join(obj-keys, \", \")\n            ))\n          end\n        end;\n        reduce(keys(first-coll), (acc, k) -> do\n          let a = for (coll in all-colls) -> coll(k);\n          assoc(acc, k, apply(fn, a))\n        end, {})\n      end\n\n      case string?(first-coll) then do\n        doseq (s in other-colls) -> do\n          if not(string?(s)) then\n            perform(effect(dvala.error), \"Expected string\")\n          end\n        end;\n        let len = reduce(other-colls, (m, s) -> min(m, count(s)), count(first-coll));\n        let mapped = for (i in range(len)) -> do\n          let a = for (coll in all-colls) -> nth(coll, i);\n          apply(fn, a)\n        end;\n        reduce(mapped, (acc, ch) -> do\n          if not(string?(ch)) then\n            perform(effect(dvala.error), \"Expected string\")\n          end;\n          ++(acc, ch)\n        end, \"\")\n      end\n\n      case true then do\n        doseq (x in other-colls) -> do\n          if not(array?(x)) then\n            perform(effect(dvala.error), \"Expected array\")\n          end\n        end;\n        let len = reduce(other-colls, (m, x) -> min(m, count(x)), count(first-coll));\n        for (i in range(len)) -> do\n          let a = for (coll in all-colls) -> nth(coll, i);\n          apply(fn, a)\n        end\n      end\n    end\n  end,\n\n  filter: (coll, fn) -> do\n    cond\n      case array?(coll) then\n        reduce(coll, (acc, elem) -> if fn(elem) then [...acc, elem] else acc end, [])\n\n      case string?(coll) then\n        reduce(coll, (acc, ch) -> if fn(ch) then ++(acc, ch) else acc end, \"\")\n\n      case object?(coll) then\n        reduce(keys(coll), (acc, k) -> do\n          if fn(coll(k)) then\n            assoc(acc, k, coll(k))\n          else\n            acc\n          end\n        end, {})\n\n      case true then\n        perform(effect(dvala.error), \"Expected collection\")\n    end\n  end,\n\n  reduce: (coll, fn, initial) -> do\n    cond\n      case string?(coll) then\n        loop (acc = initial, i = 0) -> do\n          if i >= count(coll) then\n            acc\n          else\n            recur(fn(acc, nth(coll, i)), i + 1)\n          end\n        end\n\n      case array?(coll) then\n        loop (acc = initial, i = 0) -> do\n          if i >= count(coll) then\n            acc\n          else\n            recur(fn(acc, nth(coll, i)), i + 1)\n          end\n        end\n\n      case object?(coll) then do\n        let values = vals(coll);\n        loop (acc = initial, i = 0) -> do\n          if i >= count(values) then\n            acc\n          else\n            recur(fn(acc, nth(values, i)), i + 1)\n          end\n        end\n      end\n\n      case true then\n        perform(effect(dvala.error), \"Expected collection\")\n    end\n  end\n}",
+	collection: "{\n  map: (first-coll, ...args) -> do\n    let fn = last(args);\n    let other-colls = slice(args, 0, count(args) - 1);\n    let all-colls = [first-coll, ...other-colls];\n\n    cond\n      case object?(first-coll) then do\n        let expected-keys = keys(first-coll) |> sort;\n        doseq (obj in other-colls) -> do\n          if not(object?(obj)) then\n            perform(@dvala.error, \"Expected object\")\n          end;\n          let obj-keys = keys(obj) |> sort;\n          if not(obj-keys == expected-keys) then\n            perform(@dvala.error, ++(\n              \"All objects must have the same keys. Expected: \",\n              join(expected-keys, \", \"),\n              \". Found: \",\n              join(obj-keys, \", \")\n            ))\n          end\n        end;\n        reduce(keys(first-coll), (acc, k) -> do\n          let a = for (coll in all-colls) -> coll(k);\n          assoc(acc, k, apply(fn, a))\n        end, {})\n      end\n\n      case string?(first-coll) then do\n        doseq (s in other-colls) -> do\n          if not(string?(s)) then\n            perform(@dvala.error, \"Expected string\")\n          end\n        end;\n        let len = reduce(other-colls, (m, s) -> min(m, count(s)), count(first-coll));\n        let mapped = for (i in range(len)) -> do\n          let a = for (coll in all-colls) -> nth(coll, i);\n          apply(fn, a)\n        end;\n        reduce(mapped, (acc, ch) -> do\n          if not(string?(ch)) then\n            perform(@dvala.error, \"Expected string\")\n          end;\n          ++(acc, ch)\n        end, \"\")\n      end\n\n      case true then do\n        doseq (x in other-colls) -> do\n          if not(array?(x)) then\n            perform(@dvala.error, \"Expected array\")\n          end\n        end;\n        let len = reduce(other-colls, (m, x) -> min(m, count(x)), count(first-coll));\n        for (i in range(len)) -> do\n          let a = for (coll in all-colls) -> nth(coll, i);\n          apply(fn, a)\n        end\n      end\n    end\n  end,\n\n  filter: (coll, fn) -> do\n    cond\n      case array?(coll) then\n        reduce(coll, (acc, elem) -> if fn(elem) then [...acc, elem] else acc end, [])\n\n      case string?(coll) then\n        reduce(coll, (acc, ch) -> if fn(ch) then ++(acc, ch) else acc end, \"\")\n\n      case object?(coll) then\n        reduce(keys(coll), (acc, k) -> do\n          if fn(coll(k)) then\n            assoc(acc, k, coll(k))\n          else\n            acc\n          end\n        end, {})\n\n      case true then\n        perform(@dvala.error, \"Expected collection\")\n    end\n  end,\n\n  reduce: (coll, fn, initial) -> do\n    cond\n      case string?(coll) then\n        loop (acc = initial, i = 0) -> do\n          if i >= count(coll) then\n            acc\n          else\n            recur(fn(acc, nth(coll, i)), i + 1)\n          end\n        end\n\n      case array?(coll) then\n        loop (acc = initial, i = 0) -> do\n          if i >= count(coll) then\n            acc\n          else\n            recur(fn(acc, nth(coll, i)), i + 1)\n          end\n        end\n\n      case object?(coll) then do\n        let values = vals(coll);\n        loop (acc = initial, i = 0) -> do\n          if i >= count(values) then\n            acc\n          else\n            recur(fn(acc, nth(values, i)), i + 1)\n          end\n        end\n      end\n\n      case true then\n        perform(@dvala.error, \"Expected collection\")\n    end\n  end\n}",
 	sequence: "{\n  some: (seq, fn) -> do\n    if null?(seq) then null\n    else do\n      loop (i = 0) -> do\n        if i >= count(seq) then\n          null\n        else do\n          let elem = nth(seq, i);\n          if fn(elem) then elem\n          else recur(i + 1)\n          end\n        end\n        end\n      end\n    end\n    end\n  end,\n\n  take-while: (seq, fn) -> do\n    let is-str = string?(seq);\n    let len = count(seq);\n    let idx = loop (i = 0) -> do\n      if i >= len then\n        len\n      else if fn(nth(seq, i)) then\n        recur(i + 1)\n      else\n        i\n      end\n      end\n    end;\n    slice(seq, 0, idx)\n  end,\n\n  drop-while: (seq, fn) -> do\n    let is-str = string?(seq);\n    let len = count(seq);\n    let idx = loop (i = 0) -> do\n      if i >= len then\n        len\n      else if fn(nth(seq, i)) then\n        recur(i + 1)\n      else\n        i\n      end\n      end\n    end;\n    slice(seq, idx)\n  end,\n\n  sort: (seq, ...args) -> do\n    let cmp = if count(args) == 0 then compare else first(args) end;\n    let is-str = string?(seq);\n    let arr = if is-str then split(seq, \"\") else seq end;\n    let len = count(arr);\n\n    // merge two sorted arrays\n    let merge-arrays = (left, right) -> do\n      let left-len = count(left);\n      let right-len = count(right);\n      loop (result = [], li = 0, ri = 0) -> do\n        if li >= left-len then\n          ++(result, slice(right, ri))\n        else if ri >= right-len then\n          ++(result, slice(left, li))\n        else do\n          let l = nth(left, li);\n          let r = nth(right, ri);\n          if cmp(l, r) <= 0 then\n            recur(push(result, l), li + 1, ri)\n          else\n            recur(push(result, r), li, ri + 1)\n          end\n        end\n        end\n        end\n      end\n    end;\n\n    // recursive merge-sort\n    let merge-sort = (a) -> do\n      let n = count(a);\n      if n <= 1 then a\n      else do\n        let mid = floor(n / 2);\n        let left = merge-sort(slice(a, 0, mid));\n        let right = merge-sort(slice(a, mid));\n        merge-arrays(left, right)\n      end\n      end\n    end;\n\n    let sorted = merge-sort(arr);\n    if is-str then join(sorted, \"\") else sorted end\n  end\n}\n",
-	array: "{\n  mapcat: (arr, fn) -> do\n    flatten(map(arr, fn), 1)\n  end,\n\n  moving-fn: (arr, window-size, fn) -> do\n    if window-size > count(arr) then\n      perform(effect(dvala.error), \"Expected window-size <= array length\")\n    end;\n    for (i in range(count(arr) - window-size + 1)) -> do\n      fn(slice(arr, i, i + window-size))\n    end\n  end,\n\n  running-fn: (arr, fn) -> do\n    for (i in range(count(arr))) -> do\n      fn(slice(arr, 0, i + 1))\n    end\n  end\n}\n",
+	array: "{\n  mapcat: (arr, fn) -> do\n    flatten(map(arr, fn), 1)\n  end,\n\n  moving-fn: (arr, window-size, fn) -> do\n    if window-size > count(arr) then\n      perform(@dvala.error, \"Expected window-size <= array length\")\n    end;\n    for (i in range(count(arr) - window-size + 1)) -> do\n      fn(slice(arr, i, i + window-size))\n    end\n  end,\n\n  running-fn: (arr, fn) -> do\n    for (i in range(count(arr))) -> do\n      fn(slice(arr, 0, i + 1))\n    end\n  end\n}\n",
 	functional: "{\n  \"|>\": (a, b) -> b(a),\n\n  apply: (fn, ...args) -> do\n    let arr = last(args);\n    let leading = slice(args, 0, count(args) - 1);\n    fn(...leading, ...arr)\n  end\n}\n",
-	object: "{\n  merge-with: (...args) -> do\n    let fn = last(args);\n    let objs = slice(args, 0, count(args) - 1);\n    if not(function?(fn)) then\n      perform(effect(dvala.error), str(\"Expected function, got: \", type(fn)))\n    end;\n    if count(objs) == 0 then\n      perform(effect(dvala.error), \"Expected at least one object argument\")\n    end;\n    reduce(rest(objs), (result, obj) -> do\n      if not(object?(obj)) then\n        perform(effect(dvala.error), str(\"Expected object, got: \", type(obj)))\n      end;\n      reduce(keys(obj), (res, key) -> do\n        if contains?(res, key) then\n          assoc(res, key, fn(get(res, key), get(obj, key)))\n        else\n          assoc(res, key, get(obj, key))\n        end\n      end, result)\n    end, do\n      let f = first(objs);\n      if not(object?(f)) then\n        perform(effect(dvala.error), str(\"Expected object, got: \", type(f)))\n      end;\n      f\n    end)\n  end\n}\n"
+	object: "{\n  merge-with: (...args) -> do\n    let fn = last(args);\n    let objs = slice(args, 0, count(args) - 1);\n    if not(function?(fn)) then\n      perform(@dvala.error, str(\"Expected function, got: \", type(fn)))\n    end;\n    if count(objs) == 0 then\n      perform(@dvala.error, \"Expected at least one object argument\")\n    end;\n    reduce(rest(objs), (result, obj) -> do\n      if not(object?(obj)) then\n        perform(@dvala.error, str(\"Expected object, got: \", type(obj)))\n      end;\n      reduce(keys(obj), (res, key) -> do\n        if contains?(res, key) then\n          assoc(res, key, fn(get(res, key), get(obj, key)))\n        else\n          assoc(res, key, get(obj, key))\n        end\n      end, result)\n    end, do\n      let f = first(objs);\n      if not(object?(f)) then\n        perform(@dvala.error, str(\"Expected object, got: \", type(f)))\n      end;\n      f\n    end)\n  end\n}\n"
 };
 let initialized = false;
 function initCoreDvalaSources() {

package/package.json

@@ -3,7 +3,7 @@
   "overrides": {
     "file-type": "^21.3.2"
   },
-  "version": "0.0.29",
+  "version": "0.0.31",
   "description": "A suspendable, time-traveling functional language for JavaScript with algebraic effects",
   "author": "Albert Mojir",
   "license": "MIT",