@nmnmcc/ability 2.1.1 → 2.1.3

package/src/internal/bind.ts

@@ -815,48 +815,46 @@ export const treeIssues = (
 	// shares the path of its parent. The tree may be the JSON form, with no
 	// depth that a node knows, so the walk is a walk of the trampoline for an
 	// input of an unknown depth.
-	type Found = Issue | readonly [RuleData, Place.Place]
+	// The rules go into one list, in order: a walk that joined the lists of
+	// the children at each node would copy the list of a deep tree at each
+	// level. The list belongs to this walk.
+	const found: Array<readonly [RuleData, Place.Place]> = []
 	const rulesOf = Trampoline.adaptive<
 		{ readonly node: TreeNode; readonly at: At },
-		ReadonlyArray<Found>
+		undefined
 	>((R, child) => ({ node, at }, level) => {
+		const below = (
+			parts: ReadonlyArray<{ readonly node: TreeNode; readonly at: At }>,
+		) =>
+			R.map(
+				R.forEach(parts, (part) => child(part, level + 1)),
+				() => undefined,
+			)
 		switch (node._tag) {
 			case "Rules":
-				return R.succeed(
-					Arr.map(
-						node.rules,
-						(rule, index) => [rule, Place.at(at, "rules", index)] as const,
-					),
-				)
+				Arr.forEach(node.rules, (rule, index) => {
+					found.push([rule, Place.at(at, "rules", index)])
+				})
+				return R.succeed(undefined)
 			case "All":
 			case "Any":
 			case "FirstOf":
-				return R.map(
-					R.forEach(node.policies, (inner, index) =>
-						child(
-							{ node: inner, at: Place.at(at, "policies", index) },
-							level + 1,
-						),
-					),
-					Arr.flatten,
+				return below(
+					Arr.map(node.policies, (inner, index) => ({
+						node: inner,
+						at: Place.at(at, "policies", index),
+					})),
 				)
 			case "Ceiling":
-				return R.map(
-					R.forEach(
-						[
-							{ node: node.cap, at: Place.at(at, "cap") },
-							{ node: node.policy, at: Place.at(at, "policy") },
-						],
-						(part) => child(part, level + 1),
-					),
-					Arr.flatten,
-				)
+				return below([
+					{ node: node.cap, at: Place.at(at, "cap") },
+					{ node: node.policy, at: Place.at(at, "policy") },
+				])
 		}
 	})
+	rulesOf({ node: root, at: undefined })
 	const memo = makeMemo(domain.limits)
-	return Arr.flatMap(rulesOf({ node: root, at: undefined }), (found) =>
-		Array.isArray(found)
-			? ruleIssues(domain, found[0], found[1], memo)
-			: [found as Issue],
+	return Arr.flatMap(found, ([rule, place]) =>
+		ruleIssues(domain, rule, place, memo),
 	)
 }

package/src/internal/catalog.ts

@@ -18,6 +18,7 @@ import { hasProperty } from "effect/Predicate"
 import * as Schema from "effect/Schema"
 import * as SchemaAST from "effect/SchemaAST"
 import * as Limits from "./limits.ts"
+import * as Trampoline from "./trampoline.ts"
 
 /** The kinds of values that a field may hold. */
 export interface Kinds {
@@ -234,18 +235,31 @@ const classStruct = (
 const alternatives = (
 	ast: SchemaAST.AST,
 	open: ReadonlySet<SchemaAST.AST>,
-): ReadonlyArray<SchemaAST.AST> => {
+): ReadonlyArray<SchemaAST.AST> => alternativesOf({ ast, open })
+
+/**
+ * The walk of {@link alternatives}. A union may hold a union, very many
+ * levels down, so it is a walk of the trampoline for an input of an unknown
+ * depth.
+ */
+const alternativesOf = Trampoline.adaptive<
+	{ readonly ast: SchemaAST.AST; readonly open: ReadonlySet<SchemaAST.AST> },
+	ReadonlyArray<SchemaAST.AST>
+>((R, child) => ({ ast, open }, depth) => {
 	switch (ast._tag) {
 		case "Union":
-			return Arr.flatMap(ast.types, (type) => alternatives(type, open))
+			return R.map(
+				R.forEach(ast.types, (type) => child({ ast: type, open }, depth + 1)),
+				Arr.flatten,
+			)
 		case "Suspend":
 			return open.has(ast)
-				? []
-				: alternatives(ast.thunk(), new Set([...open, ast]))
+				? R.succeed([])
+				: child({ ast: ast.thunk(), open: new Set([...open, ast]) }, depth + 1)
 		default:
-			return [ast]
+			return R.succeed([ast])
 	}
-}
+})
 
 /** The struct of a Schema: a struct, or the struct of a class. */
 const structOf = (ast: SchemaAST.AST): SchemaAST.Objects | undefined =>
@@ -258,13 +272,30 @@ const structOf = (ast: SchemaAST.AST): SchemaAST.Objects | undefined =>
 const hasCheck = (
 	checks: ReadonlyArray<SchemaAST.Check<never>>,
 	id: string,
-): boolean =>
-	Arr.some(
-		checks,
-		(check) =>
-			check.annotations?.representation?.id === id ||
-			(check._tag === "FilterGroup" && hasCheck(check.checks, id)),
-	)
+): boolean => hasCheckIn({ checks, id })
+
+/**
+ * The walk of {@link hasCheck}. A group of checks may hold a group, very many
+ * levels down, as `.and(...)` many times makes, so it is a walk of the
+ * trampoline for an input of an unknown depth.
+ */
+const hasCheckIn = Trampoline.adaptive<
+	{
+		readonly checks: ReadonlyArray<SchemaAST.Check<never>>
+		readonly id: string
+	},
+	boolean
+>(
+	(R, child) =>
+		({ checks, id }, depth) =>
+			R.some(checks, (check) =>
+				check.annotations?.representation?.id === id
+					? R.succeed(true)
+					: check._tag === "FilterGroup"
+						? child({ checks: check.checks, id }, depth + 1)
+						: R.succeed(false),
+			),
+)
 
 /** A struct with named fields, or with the keys of a record. */
 const isStruct = (
@@ -667,7 +698,12 @@ const listOf = (
 			if (visit === undefined) {
 				return Option.none()
 			}
-			rest.push(...Arr.reverse(below(visit)))
+			// The visits go onto the stack one at a time: a spread into a call
+			// would pass one argument for each field, past the most arguments
+			// of a call.
+			Arr.forEach(Arr.reverse(below(visit)), (next) => {
+				rest.push(next)
+			})
 			const field =
 				visit.path.length === 0
 					? []

package/src/internal/decide.ts

@@ -388,7 +388,9 @@ export const permittedFields = (
 	const rules = policy.pipe(nodeOf, PolicyNodes.rulesOf)
 	// The fields with names only: a list can not name every key of a record.
 	const listed = Arr.filter(
-		descriptor.catalog.fields,
+		// The list for the limit of the parts of a path of the domain, as the
+		// decision of each field reads it.
+		Catalog.fieldsOf(descriptor.catalog, policy.domain.limits.fieldPathParts),
 		(field) =>
 			field.listed &&
 			Arr.every(field.path, (segment) => typeof segment === "string"),

package/src/internal/patterns.ts

@@ -201,11 +201,13 @@ export const matchesBelow = (
 /**
  * Tests if a pattern matches some field of a catalog, with at most `parts`
  * parts. A recursive Schema has no end of fields, so the search goes over the
- * pairs of a place of the catalog and the places of the match: each pair
- * comes one time, a level after a level, so the search is short, and it
- * keeps a queue, so a deep Schema does not fill the stack. The set of the
- * pairs is native, with keys that are numbers, and the set and the queue
- * belong to this call.
+ * pairs of a place of the catalog and one place of the match. There are at
+ * most the places of the catalog times the parts of the pattern of them, so
+ * the work is the steps of the catalog times the parts of the pattern, as the
+ * binding counts it. Each pair comes one time, a level after a level, so the
+ * search finds the shortest field first, and it keeps a queue, so a deep
+ * Schema does not fill the stack. The set of the pairs is native, and the set
+ * and the queue belong to this call.
  */
 export const fitsCatalog = (
 	pattern: Pattern,
@@ -214,46 +216,52 @@ export const fitsCatalog = (
 ): boolean => {
 	interface Visit {
 		readonly branch: Catalog.Branch
-		readonly states: States
+		readonly state: number
 		readonly depth: number
 	}
 	const seen = new Set<string>()
-	const next = (visit: Visit): ReadonlyArray<Visit> => {
-		if (visit.states.length === 0 || visit.depth === parts) {
-			return []
-		}
-		const steps: ReadonlyArray<readonly [Catalog.Segment, number]> = [
-			...visit.branch.children,
-			...(visit.branch.key === undefined || visit.branch.keyBranch === undefined
-				? []
-				: [[visit.branch.key, visit.branch.keyBranch] as const]),
-		]
-		return Arr.flatMap(steps, ([segment, id]) => {
-			const states = step(pattern, visit.states, segment)
-			const key = `${String(id)}|${states.join(",")}`
-			if (states.length === 0 || seen.has(key)) {
+	const visits = (
+		id: number,
+		states: States,
+		depth: number,
+	): ReadonlyArray<Visit> =>
+		Arr.flatMap(states, (state) => {
+			const key = `${String(id)}|${String(state)}`
+			if (seen.has(key)) {
 				return []
 			}
 			seen.add(key)
-			return [{ branch: catalog.branches[id]!, states, depth: visit.depth + 1 }]
+			return [{ branch: catalog.branches[id]!, state, depth }]
 		})
+	const next = (visit: Visit): ReadonlyArray<Visit> => {
+		if (visit.depth === parts) {
+			return []
+		}
+		const branch = visit.branch
+		const steps: ReadonlyArray<readonly [Catalog.Segment, number]> =
+			branch.key === undefined || branch.keyBranch === undefined
+				? branch.children
+				: [...branch.children, [branch.key, branch.keyBranch] as const]
+		return Arr.flatMap(steps, ([segment, id]) =>
+			visits(id, step(pattern, [visit.state], segment), visit.depth + 1),
+		)
 	}
-	const queue: Array<Visit> = [
-		{ branch: catalog.root, states: start(pattern), depth: 0 },
-	]
-	// The walk stops at the first field that the pattern matches.
-	const found = (visit: Visit) =>
-		visit.depth > 0 && isDone(pattern, visit.states)
+	const queue: Array<Visit> = [...visits(catalog.root.id, start(pattern), 0)]
+	// The walk stops at the first field that the pattern matches. The visits
+	// go into the queue one at a time: a spread into a call would pass one
+	// argument for each, past the most arguments of a call.
 	return Arr.some(
 		Arr.unfold(0, (index) => {
 			const visit = queue[index]
 			if (visit === undefined) {
 				return Option.none()
 			}
-			if (found(visit)) {
+			if (visit.depth > 0 && visit.state === pattern.length) {
 				return Option.some([true, queue.length] as const)
 			}
-			queue.push(...next(visit))
+			Arr.forEach(next(visit), (found) => {
+				queue.push(found)
+			})
 			return Option.some([false, index + 1] as const)
 		}),
 		(match) => match,

package/src/internal/policy-nodes.ts

@@ -196,29 +196,35 @@ export const isNode = (u: unknown): u is Node => u instanceof Base
  * into the condition of each rule takes the rules from this list first, so it
  * does not go down the levels of the tree and of a condition at once.
  */
-export const rulesOf = (root: Node): ReadonlyArray<Rule.Rule> =>
+export const rulesOf = (root: Node): ReadonlyArray<Rule.Rule> => {
+	// The rules go into one list, in order. A walk that joined the lists of
+	// the children at each node would copy the list of a deep tree at each
+	// level. The list belongs to this walk.
+	const rules: Array<Rule.Rule> = []
 	// The walk takes the steps of a trampoline, so a deep tree does not fill
 	// the stack.
 	Trampoline.run(root.depth, (R) => {
-		const go = (node: Node): Trampoline.Step<ReadonlyArray<Rule.Rule>> => {
+		const children = (nodes: ReadonlyArray<Node>) =>
+			R.map(
+				R.forEach(nodes, (child) => R.suspend(() => go(child))),
+				() => undefined,
+			)
+		const go = (node: Node): Trampoline.Step<undefined> => {
 			switch (node._tag) {
 				case "Rules":
-					return R.succeed(node.rules)
+					Arr.forEach(node.rules, (rule) => {
+						rules.push(rule)
+					})
+					return R.succeed(undefined)
 				case "All":
 				case "Any":
 				case "FirstOf":
-					return R.map(
-						R.forEach(node.policies, (child) => R.suspend(() => go(child))),
-						Arr.flatten,
-					)
+					return children(node.policies)
 				case "Ceiling":
-					return R.map(
-						R.forEach([node.cap, node.policy], (child) =>
-							R.suspend(() => go(child)),
-						),
-						Arr.flatten,
-					)
+					return children([node.cap, node.policy])
 			}
 		}
 		return go(root)
 	})
+	return rules
+}

package/src/internal/search.ts

@@ -317,28 +317,35 @@ const fix = (root: Node, field: string, value: unknown, search: Search): Node =>
 	})
 
 /** The fields of the tests of a condition, once for each test. */
-const testedFields = (root: Node): ReadonlyArray<string> =>
+const testedFields = (root: Node): ReadonlyArray<string> => {
+	// The fields go into one list, in order. A walk that joined the lists of
+	// the children would copy the list of a deep condition at each level. The
+	// list belongs to this walk.
+	const fields: Array<string> = []
 	Trampoline.run(root.depth, (R) => {
-		const go = (node: Node): Trampoline.Step<ReadonlyArray<string>> => {
+		const go = (node: Node): Trampoline.Step<undefined> => {
 			switch (node._tag) {
 				case "Compare":
 				case "In":
 				case "Exists":
-					return R.succeed([node.field])
+					fields.push(node.field)
+					return R.succeed(undefined)
 				case "And":
 				case "Or":
 					return R.map(
 						R.forEach(node.conditions, (child) => R.suspend(() => go(child))),
-						Arr.flatten,
+						() => undefined,
 					)
 				case "Not":
 					return R.suspend(() => go(node.condition))
 				default:
-					return R.succeed([])
+					return R.succeed(undefined)
 			}
 		}
 		return go(root)
 	})
+	return fields
+}
 
 /**
  * Picks the next field to split on. A field comes before the fields below it,
@@ -486,20 +493,29 @@ const exampleOf = (
  * belongs to one search.
  */
 const constantsOf = (node: Node): Map<string, Set<Nodes.Scalar>> => {
-	type Pair = readonly [string, ReadonlyArray<Nodes.Scalar>]
+	// The constants go into one map as the walk finds them. A walk that
+	// joined the lists of the children would copy the list of a deep
+	// condition at each level. The map belongs to one search.
+	const all = new Map<string, Set<Nodes.Scalar>>()
+	const add = (field: string, values: ReadonlyArray<Nodes.Scalar>): void => {
+		const known = all.get(field) ?? new Set<Nodes.Scalar>()
+		Arr.forEach(values, (value) => known.add(value))
+		all.set(field, known)
+	}
 	// The walk takes the steps of a trampoline, so a deep condition does not
 	// fill the stack.
-	const pairs = Trampoline.run(node.depth, (R) => {
-		const go = (current: Node): Trampoline.Step<ReadonlyArray<Pair>> => {
+	Trampoline.run(node.depth, (R) => {
+		const go = (current: Node): Trampoline.Step<undefined> => {
 			switch (current._tag) {
 				case "Compare":
-					return R.succeed([[current.field, [literalOf(current.value)]]])
+					add(current.field, [literalOf(current.value)])
+					return R.succeed(undefined)
 				case "In":
-					return R.succeed([
-						[current.field, Arr.map(current.values, literalOf)],
-					])
+					add(current.field, Arr.map(current.values, literalOf))
+					return R.succeed(undefined)
 				case "Exists":
-					return R.succeed([[current.field, []]])
+					add(current.field, [])
+					return R.succeed(undefined)
 				case "Under":
 					throw new Error(
 						"Condition.satisfiable needs a condition with no Under nodes. Call Condition.partial first.",
@@ -510,22 +526,16 @@ const constantsOf = (node: Node): Map<string, Set<Nodes.Scalar>> => {
 						R.forEach(current.conditions, (child) =>
 							R.suspend(() => go(child)),
 						),
-						Arr.flatten,
+						() => undefined,
 					)
 				case "Not":
 					return R.suspend(() => go(current.condition))
 				default:
-					return R.succeed([])
+					return R.succeed(undefined)
 			}
 		}
 		return go(node)
 	})
-	const all = new Map<string, Set<Nodes.Scalar>>()
-	Arr.forEach(pairs, ([field, values]) => {
-		const known = all.get(field) ?? new Set<Nodes.Scalar>()
-		Arr.forEach(values, (value) => known.add(value))
-		all.set(field, known)
-	})
 	return all
 }