@elaraai/east 1.0.97 → 1.0.99

package/dist/src/expr/index.d.ts

@@ -28,6 +28,8 @@ import { from, equal, notEqual, less, lessEqual, print, is, greaterEqual, greate
 import { toSource } from '../codegen/index.js';
 import { importFunction, exportFunctions, encodeFunctionManifest, decodeFunctionManifest, linkImports, platformDependencies } from '../functions.js';
 import { jq } from './query.js';
+import { field, fields, inCase, patchesFor, struct, withField } from './named.js';
+export { type Patches } from './named.js';
 export { BlockBuilder, type AsyncPlatformDefinition, type PlatformDefinition, type GenericPlatformDefinition, type AsyncGenericPlatformDefinition, type PlatformDeclaration, PLATFORM_DECLARATION, isPlatformDeclaration, equals, eq, notEquals, ne, lessThan, lt, lessThanOrEqual, lte, le, greaterThan, gt, greaterThanOrEqual, gte, ge, diff, applyPatch, composePatch, invertPatch } from './block.js';
 export type { ToExpr as ExprFactory } from './expr.js';
 /**
@@ -662,6 +664,134 @@ export declare const East: {
      * ```
      */
     invertPatch: typeof invertPatch;
+    /**
+     * Reads a struct's field by a name held as a value — what `value.name`
+     * reads where the name is written — for code building East programs over
+     * types it is handed. A recursive value is read through to its node.
+     *
+     * @param value - A struct, or a recursive value whose node is one
+     * @param name - The field
+     * @param type - The field's type, where the caller holds it: checked, and the expression typed by it
+     * @returns The field's expression
+     * @throws {Error} When the value is not a struct, has no field of the name, or the field is not of the type given —
+     *   as the program is built
+     *
+     * @example
+     * ```ts
+     * const Row = StructType({ name: StringType, site: StringType });
+     * const readOf = (name: string) => East.function([Row], StringType, ($, row) => East.field(row, name, StringType));
+     * const compiled = East.compile(readOf("site"), []);
+     * compiled({ name: "Press 1", site: "North" });  // "North"
+     * ```
+     */
+    field: typeof field;
+    /**
+     * A struct's fields by names held as values: each field's expression, in
+     * the order given, or in the struct's own — to spread into a call, or into
+     * {@link East.struct}. The value is read once a field: give a variable.
+     *
+     * @param value - A struct, or a recursive value whose node is one
+     * @param names - The fields, in the order wanted; every field, in the struct's order, where none are given
+     * @returns The fields' expressions
+     * @throws {Error} When the value is not a struct, or has no field of a name given — as the program is built
+     *
+     * @example
+     * ```ts
+     * const Row = StructType({ name: StringType, site: StringType, status: StringType });
+     * const Place = StructType({ site: StringType, name: StringType });
+     * const placeOf = East.function([Row], Place, ($, row) => East.struct(Place, East.fields(row, ["site", "name"])));
+     * const compiled = East.compile(placeOf, []);
+     * compiled({ name: "Press 1", site: "North", status: "up" });  // { site: "North", name: "Press 1" }
+     * ```
+     */
+    fields: typeof fields;
+    /**
+     * Builds a struct of a type held as a value from its fields, by name or in
+     * the type's order — what a struct literal builds where its names are
+     * written. A recursive type's node is built, and wrapped in it.
+     *
+     * @param type - A struct type, or a recursive type whose node is one
+     * @param values - Each field's value or expression: by name, every field once; or in the type's order, one a field
+     * @returns The struct's expression
+     * @throws {Error} When the type is not a struct, a name is not one of its fields, a field has no value, or a value
+     *   is not of its field's type — as the program is built
+     *
+     * @example
+     * ```ts
+     * const Pair = StructType({ low: IntegerType, high: IntegerType });
+     * const ordered = East.function([IntegerType, IntegerType], Pair, ($, a, b) =>
+     *   East.struct(Pair, [East.min(a, b), East.max(a, b)]));
+     * const compiled = East.compile(ordered, []);
+     * compiled(7n, 3n);  // { low: 3n, high: 7n }
+     * ```
+     */
+    struct: typeof struct;
+    /**
+     * A struct with one field replaced, by a name held as a value: the same
+     * type, every other field as it is. A recursive value's node is rebuilt,
+     * and wrapped again. The value is read once a field: give a variable.
+     *
+     * @param value - A struct, or a recursive value whose node is one
+     * @param name - The field replaced
+     * @param replacement - Its new value or expression
+     * @returns The struct with the field replaced
+     * @throws {Error} When the value is not a struct, has no field of the name, or the replacement is not of its type —
+     *   as the program is built
+     *
+     * @example
+     * ```ts
+     * const Row = StructType({ name: StringType, status: StringType });
+     * const stopped = East.function([Row], Row, ($, row) => East.withField(row, "status", "down"));
+     * const compiled = East.compile(stopped, []);
+     * compiled({ name: "Press 1", status: "up" });  // { name: "Press 1", status: "down" }
+     * ```
+     */
+    withField: typeof withField;
+    /**
+     * A variant of a type held as a value, holding a value in a case by a name
+     * held as a value — what `variant(name, value)` builds where the case is
+     * written. A recursive type's node is built, and wrapped in it.
+     *
+     * @param type - A variant type, or a recursive type whose node is one
+     * @param name - The case
+     * @param value - Its value or expression
+     * @returns The variant's expression
+     * @throws {Error} When the type is not a variant, has no case of the name, or the value is not of the case's type —
+     *   as the program is built
+     *
+     * @example
+     * ```ts
+     * const Reading = VariantType({ load: FloatType, output: FloatType });
+     * const readingOf = (place: string) => East.function([FloatType], Reading, ($, x) => East.inCase(Reading, place, x));
+     * const compiled = East.compile(readingOf("output"), []);
+     * compiled(0.82);  // variant("output", 0.82)
+     * ```
+     */
+    inCase: typeof inCase;
+    /**
+     * The patch functions of a type held as a value: diff, apply, compose and
+     * invert, each an East function of the type, bound and called as any other
+     * — what {@link East.diff}, {@link East.applyPatch},
+     * {@link East.composePatch} and {@link East.invertPatch} build where the
+     * type is written.
+     *
+     * @param type - The type patched
+     * @returns Its patch type, and its patch functions
+     *
+     * @example
+     * ```ts
+     * const Row = StructType({ name: StringType, status: StringType });
+     * const { diff, apply } = East.patchesFor(Row);
+     * const roundTrip = East.function([Row, Row], Row, ($, before, after) => {
+     *   const diffFn = $.const(diff);
+     *   const applyFn = $.const(apply);
+     *   return applyFn(before, diffFn(before, after));
+     * });
+     * const compiled = East.compile(roundTrip, []);
+     * compiled({ name: "Press 1", status: "up" }, { name: "Press 1", status: "down" });  // { name: "Press 1", status: "down" }
+     * ```
+     */
+    patchesFor: typeof patchesFor;
     /**
      * A jq query over East values, as East code: parsed, checked against the
      * inputs' types and translated to ordinary East IR when the program is

package/dist/src/expr/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/expr/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/expr/index.ts"],"names":[],"mappings":"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"}

package/dist/src/expr/index.js

@@ -31,6 +31,8 @@ import { from, equal, notEqual, less, lessEqual, print, is, greaterEqual, greate
 import { toSource } from '../codegen/index.js';
 import { importFunction, exportFunctions, encodeFunctionManifest, decodeFunctionManifest, linkImports, platformDependencies } from '../functions.js';
 import { jq } from './query.js';
+import { field, fields, inCase, patchesFor, struct, withField } from './named.js';
+export {} from './named.js';
 export { BlockBuilder, PLATFORM_DECLARATION, isPlatformDeclaration, equals, eq, notEquals, ne, lessThan, lt, lessThanOrEqual, lte, le, greaterThan, gt, greaterThanOrEqual, gte, ge, diff, applyPatch, composePatch, invertPatch } from './block.js';
 // Import standard libraries
 import IntegerLib from './libs/integer.js';
@@ -704,6 +706,137 @@ export const East = {
      */
     invertPatch,
     // ============================================================================
+    // Names and types held as values
+    // ============================================================================
+    /**
+     * Reads a struct's field by a name held as a value — what `value.name`
+     * reads where the name is written — for code building East programs over
+     * types it is handed. A recursive value is read through to its node.
+     *
+     * @param value - A struct, or a recursive value whose node is one
+     * @param name - The field
+     * @param type - The field's type, where the caller holds it: checked, and the expression typed by it
+     * @returns The field's expression
+     * @throws {Error} When the value is not a struct, has no field of the name, or the field is not of the type given —
+     *   as the program is built
+     *
+     * @example
+     * ```ts
+     * const Row = StructType({ name: StringType, site: StringType });
+     * const readOf = (name: string) => East.function([Row], StringType, ($, row) => East.field(row, name, StringType));
+     * const compiled = East.compile(readOf("site"), []);
+     * compiled({ name: "Press 1", site: "North" });  // "North"
+     * ```
+     */
+    field,
+    /**
+     * A struct's fields by names held as values: each field's expression, in
+     * the order given, or in the struct's own — to spread into a call, or into
+     * {@link East.struct}. The value is read once a field: give a variable.
+     *
+     * @param value - A struct, or a recursive value whose node is one
+     * @param names - The fields, in the order wanted; every field, in the struct's order, where none are given
+     * @returns The fields' expressions
+     * @throws {Error} When the value is not a struct, or has no field of a name given — as the program is built
+     *
+     * @example
+     * ```ts
+     * const Row = StructType({ name: StringType, site: StringType, status: StringType });
+     * const Place = StructType({ site: StringType, name: StringType });
+     * const placeOf = East.function([Row], Place, ($, row) => East.struct(Place, East.fields(row, ["site", "name"])));
+     * const compiled = East.compile(placeOf, []);
+     * compiled({ name: "Press 1", site: "North", status: "up" });  // { site: "North", name: "Press 1" }
+     * ```
+     */
+    fields,
+    /**
+     * Builds a struct of a type held as a value from its fields, by name or in
+     * the type's order — what a struct literal builds where its names are
+     * written. A recursive type's node is built, and wrapped in it.
+     *
+     * @param type - A struct type, or a recursive type whose node is one
+     * @param values - Each field's value or expression: by name, every field once; or in the type's order, one a field
+     * @returns The struct's expression
+     * @throws {Error} When the type is not a struct, a name is not one of its fields, a field has no value, or a value
+     *   is not of its field's type — as the program is built
+     *
+     * @example
+     * ```ts
+     * const Pair = StructType({ low: IntegerType, high: IntegerType });
+     * const ordered = East.function([IntegerType, IntegerType], Pair, ($, a, b) =>
+     *   East.struct(Pair, [East.min(a, b), East.max(a, b)]));
+     * const compiled = East.compile(ordered, []);
+     * compiled(7n, 3n);  // { low: 3n, high: 7n }
+     * ```
+     */
+    struct,
+    /**
+     * A struct with one field replaced, by a name held as a value: the same
+     * type, every other field as it is. A recursive value's node is rebuilt,
+     * and wrapped again. The value is read once a field: give a variable.
+     *
+     * @param value - A struct, or a recursive value whose node is one
+     * @param name - The field replaced
+     * @param replacement - Its new value or expression
+     * @returns The struct with the field replaced
+     * @throws {Error} When the value is not a struct, has no field of the name, or the replacement is not of its type —
+     *   as the program is built
+     *
+     * @example
+     * ```ts
+     * const Row = StructType({ name: StringType, status: StringType });
+     * const stopped = East.function([Row], Row, ($, row) => East.withField(row, "status", "down"));
+     * const compiled = East.compile(stopped, []);
+     * compiled({ name: "Press 1", status: "up" });  // { name: "Press 1", status: "down" }
+     * ```
+     */
+    withField,
+    /**
+     * A variant of a type held as a value, holding a value in a case by a name
+     * held as a value — what `variant(name, value)` builds where the case is
+     * written. A recursive type's node is built, and wrapped in it.
+     *
+     * @param type - A variant type, or a recursive type whose node is one
+     * @param name - The case
+     * @param value - Its value or expression
+     * @returns The variant's expression
+     * @throws {Error} When the type is not a variant, has no case of the name, or the value is not of the case's type —
+     *   as the program is built
+     *
+     * @example
+     * ```ts
+     * const Reading = VariantType({ load: FloatType, output: FloatType });
+     * const readingOf = (place: string) => East.function([FloatType], Reading, ($, x) => East.inCase(Reading, place, x));
+     * const compiled = East.compile(readingOf("output"), []);
+     * compiled(0.82);  // variant("output", 0.82)
+     * ```
+     */
+    inCase,
+    /**
+     * The patch functions of a type held as a value: diff, apply, compose and
+     * invert, each an East function of the type, bound and called as any other
+     * — what {@link East.diff}, {@link East.applyPatch},
+     * {@link East.composePatch} and {@link East.invertPatch} build where the
+     * type is written.
+     *
+     * @param type - The type patched
+     * @returns Its patch type, and its patch functions
+     *
+     * @example
+     * ```ts
+     * const Row = StructType({ name: StringType, status: StringType });
+     * const { diff, apply } = East.patchesFor(Row);
+     * const roundTrip = East.function([Row, Row], Row, ($, before, after) => {
+     *   const diffFn = $.const(diff);
+     *   const applyFn = $.const(apply);
+     *   return applyFn(before, diffFn(before, after));
+     * });
+     * const compiled = East.compile(roundTrip, []);
+     * compiled({ name: "Press 1", status: "up" }, { name: "Press 1", status: "down" });  // { name: "Press 1", status: "down" }
+     * ```
+     */
+    patchesFor,
+    // ============================================================================
     // Queries
     // ============================================================================
     /**

package/dist/src/expr/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/expr/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/expr/index.ts"],"names":[],"mappings":"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"}

package/dist/src/expr/named.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { type EastType } from "../types.js";
+import { Expr } from "./expr.js";
+import type { ExprType } from "./types.js";
+import type { FunctionExpr } from "./function.js";
+/**
+ * Reads a struct's field by a name held as a value — what `value.name` reads
+ * where the name is written. A recursive value is read through to its node.
+ *
+ * @typeParam T - The field's type, where the caller holds it
+ * @param value - A struct, or a recursive value whose node is one
+ * @param name - The field
+ * @param type - The field's type, where the caller holds it: checked, and the expression typed by it
+ * @returns The field's expression
+ * @throws {Error} When the value is not a struct, has no field of the name, or the field is not of the type given
+ */
+export declare function field<T extends EastType = EastType>(value: Expr, name: string, type?: T): ExprType<T>;
+/**
+ * A struct's fields, by names held as values: each field's expression, in the
+ * order given, or in the struct's own order — to spread into a call, or into
+ * {@link struct}.
+ *
+ * @param value - A struct, or a recursive value whose node is one: give a variable, for it is read once a field
+ * @param names - The fields, in the order wanted; every field, in the struct's order, where none are given
+ * @returns The fields' expressions
+ * @throws {Error} When the value is not a struct, or has no field of a name given
+ */
+export declare function fields(value: Expr, names?: readonly string[]): ExprType<EastType>[];
+/**
+ * Builds a struct of a type held as a value from its fields, given by name or
+ * in the type's order — what a struct literal builds where its names are
+ * written. A recursive type's node is built, and wrapped in it.
+ *
+ * @typeParam T - The struct's type
+ * @param type - A struct type, or a recursive type whose node is one
+ * @param values - Each field's value or expression: by name, every field once; or in the type's order, one a field
+ * @returns The struct's expression
+ * @throws {Error} When the type is not a struct, a name is not one of its fields, a field has no value, or a value is
+ *   not of its field's type
+ */
+export declare function struct<T extends EastType>(type: T, values: Readonly<Record<string, unknown>> | readonly unknown[]): ExprType<T>;
+/**
+ * A struct with one field replaced, by a name held as value: the same type,
+ * every other field as it is. A recursive value's node is rebuilt, and wrapped
+ * again.
+ *
+ * @typeParam V - The struct's expression, whose type the result keeps
+ * @param value - A struct, or a recursive value whose node is one: give a variable, for it is read once a field
+ * @param name - The field replaced
+ * @param replacement - Its new value or expression
+ * @returns The struct with the field replaced: an expression of the value's own type
+ * @throws {Error} When the value is not a struct, has no field of the name, or the replacement is not of its type
+ */
+export declare function withField<V extends Expr>(value: V, name: string, replacement: unknown): V;
+/**
+ * A variant of a type held as a value, holding a value in a case by a name
+ * held as a value — what `variant(name, value)` builds where the case is
+ * written. A recursive type's node is built, and wrapped in it.
+ *
+ * @typeParam T - The variant's type
+ * @param type - A variant type, or a recursive type whose node is one
+ * @param name - The case
+ * @param value - Its value or expression
+ * @returns The variant's expression
+ * @throws {Error} When the type is not a variant, has no case of the name, or the value is not of the case's type
+ */
+export declare function inCase<T extends EastType>(type: T, name: string, value: unknown): ExprType<T>;
+/**
+ * The patch functions of a type held as a value ({@link patchesFor}): each an
+ * East function of the type, bound and called as any other.
+ *
+ * @typeParam T - The type patched
+ */
+export interface Patches<T extends EastType = EastType> {
+    /** The type's patches, `PatchType(T)`. */
+    readonly patchType: EastType;
+    /** `(before, after) → the patch between them` */
+    readonly diff: FunctionExpr<[T, T], EastType>;
+    /** `(value, patch) → the value patched`: an East runtime error when the patch was made against another value */
+    readonly apply: FunctionExpr<[T, EastType], T>;
+    /** `(first, second) → one patch doing both`: an East runtime error when the second does not follow the first */
+    readonly compose: FunctionExpr<[EastType, EastType], EastType>;
+    /** `(patch) → the patch undoing it` */
+    readonly invert: FunctionExpr<[EastType], EastType>;
+}
+/**
+ * The patch functions of a type held as a value: diff, apply, compose and
+ * invert, each an East function of the type — what `East.diff`,
+ * `East.applyPatch`, `East.composePatch` and `East.invertPatch` build where
+ * the type is written, and the program side of `diffFor`.
+ *
+ * @typeParam T - The type patched
+ * @param type - The type
+ * @returns Its patch type and its patch functions
+ */
+export declare function patchesFor<T extends EastType>(type: T): Patches<T>;
+//# sourceMappingURL=named.d.ts.map

package/dist/src/expr/named.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"named.d.ts","sourceRoot":"","sources":["../../../src/expr/named.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAsBH,OAAO,EAAE,KAAK,QAAQ,EAAgC,MAAM,aAAa,CAAC;AAK1E,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAsBlD;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CASrG;AAED;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAGnF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,OAAO,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,CAgB/H;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,GAAG,CAAC,CAKzF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,CAM7F;AAED;;;;;GAKG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ;IACpD,0CAA0C;IAC1C,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC;IAC7B,iDAAiD;IACjD,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;IAC9C,gHAAgH;IAChH,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/C,gHAAgH;IAChH,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE,QAAQ,CAAC,CAAC;IAC/D,uCAAuC;IACvC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,CAAC;CACrD;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAgBlE"}

package/dist/src/expr/named.js

@@ -0,0 +1,182 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * East built from names and types held as values.
+ *
+ * East names a struct's fields, and a variant's cases, where its code is
+ * written: `row.jobs`, `variant("some", x)`. Code that builds East programs
+ * over types it is handed — a library generating a program for whatever record
+ * its caller declares — holds those names, and the types, as values. These
+ * build the same program pieces from them: a field read, a struct, a variant,
+ * and the patch functions of a type. Each checks its names against the type as
+ * the program is built, so a name the type does not have fails there, naming
+ * the name and the type. In TypeScript each gives an expression of the type it
+ * is handed, or of `EastType` where the type is known only as a value.
+ *
+ * A value read more than once — by {@link fields} or {@link withField} — is
+ * read from the expression given each time: give a variable (a parameter, or a
+ * `$.let`), not a computation.
+ *
+ * @packageDocumentation
+ */
+import { get_location_id } from "../location.js";
+import { isTypeEqual } from "../types.js";
+import { printTypeValueSummary } from "../type_diff.js";
+import { PatchType } from "../patch/index.js";
+import { toEastTypeValue } from "../type_of_type.js";
+import { variant } from "../containers/variant.js";
+import { Expr } from "./expr.js";
+import { builtin, from, fromAst, func, wrapRecursive } from "./block.js";
+/** A type in a refusal's words: its kind, and a struct's fields or a variant's cases by name. */
+function words(type) {
+    return printTypeValueSummary(toEastTypeValue(type), 1, 64);
+}
+/** A value read through a recursive wrapper: its node; any other value as it is. */
+function opened(value) {
+    const type = Expr.type(value);
+    if (type.type !== "Recursive")
+        return value;
+    return fromAst({ ast_type: "UnwrapRecursive", type: type.node, loc_id: get_location_id(), value: Expr.ast(value) });
+}
+/** A struct type, or a recursive type's struct node; refused, naming what was asked of it, for any other type. */
+function structOf(asked, type) {
+    const node = type.type === "Recursive" ? type.node : type;
+    if (node.type !== "Struct")
+        throw new Error(`${asked}: ${words(type)} is not a struct`);
+    return node;
+}
+/**
+ * Reads a struct's field by a name held as a value — what `value.name` reads
+ * where the name is written. A recursive value is read through to its node.
+ *
+ * @typeParam T - The field's type, where the caller holds it
+ * @param value - A struct, or a recursive value whose node is one
+ * @param name - The field
+ * @param type - The field's type, where the caller holds it: checked, and the expression typed by it
+ * @returns The field's expression
+ * @throws {Error} When the value is not a struct, has no field of the name, or the field is not of the type given
+ */
+export function field(value, name, type) {
+    const struct = opened(value);
+    const node = structOf(`East.field '${name}'`, Expr.type(value));
+    const held = node.fields[name];
+    if (held === undefined)
+        throw new Error(`East.field: ${words(node)} has no field '${name}'`);
+    if (type !== undefined && !isTypeEqual(held, type)) {
+        throw new Error(`East.field: '${name}' of ${words(node)} is ${words(held)}, not ${words(type)}`);
+    }
+    return fromAst({ ast_type: "GetField", type: held, loc_id: get_location_id(), field: name, struct: Expr.ast(struct) });
+}
+/**
+ * A struct's fields, by names held as values: each field's expression, in the
+ * order given, or in the struct's own order — to spread into a call, or into
+ * {@link struct}.
+ *
+ * @param value - A struct, or a recursive value whose node is one: give a variable, for it is read once a field
+ * @param names - The fields, in the order wanted; every field, in the struct's order, where none are given
+ * @returns The fields' expressions
+ * @throws {Error} When the value is not a struct, or has no field of a name given
+ */
+export function fields(value, names) {
+    const node = structOf("East.fields", Expr.type(value));
+    return (names ?? Object.keys(node.fields)).map((name) => field(value, name));
+}
+/**
+ * Builds a struct of a type held as a value from its fields, given by name or
+ * in the type's order — what a struct literal builds where its names are
+ * written. A recursive type's node is built, and wrapped in it.
+ *
+ * @typeParam T - The struct's type
+ * @param type - A struct type, or a recursive type whose node is one
+ * @param values - Each field's value or expression: by name, every field once; or in the type's order, one a field
+ * @returns The struct's expression
+ * @throws {Error} When the type is not a struct, a name is not one of its fields, a field has no value, or a value is
+ *   not of its field's type
+ */
+export function struct(type, values) {
+    const node = structOf("East.struct", type);
+    const names = Object.keys(node.fields);
+    let byName;
+    if (Array.isArray(values)) {
+        if (values.length !== names.length)
+            throw new Error(`East.struct: ${words(node)} has ${names.length} fields, given ${values.length}`);
+        byName = Object.fromEntries(names.map((name, at) => [name, values[at]]));
+    }
+    else {
+        byName = values;
+        const stranger = Object.keys(byName).find((name) => !names.includes(name));
+        if (stranger !== undefined)
+            throw new Error(`East.struct: ${words(node)} has no field '${stranger}'`);
+        const missing = names.find((name) => !(name in byName));
+        if (missing !== undefined)
+            throw new Error(`East.struct: no value for the field '${missing}' of ${words(node)}`);
+    }
+    const built = from(byName, node);
+    return (type.type === "Recursive" ? wrapRecursive(built, type) : built);
+}
+/**
+ * A struct with one field replaced, by a name held as value: the same type,
+ * every other field as it is. A recursive value's node is rebuilt, and wrapped
+ * again.
+ *
+ * @typeParam V - The struct's expression, whose type the result keeps
+ * @param value - A struct, or a recursive value whose node is one: give a variable, for it is read once a field
+ * @param name - The field replaced
+ * @param replacement - Its new value or expression
+ * @returns The struct with the field replaced: an expression of the value's own type
+ * @throws {Error} When the value is not a struct, has no field of the name, or the replacement is not of its type
+ */
+export function withField(value, name, replacement) {
+    const type = Expr.type(value);
+    const node = structOf("East.withField", type);
+    if (!(name in node.fields))
+        throw new Error(`East.withField: ${words(node)} has no field '${name}'`);
+    return struct(type, Object.fromEntries(Object.keys(node.fields).map((held) => [held, held === name ? replacement : field(value, held)])));
+}
+/**
+ * A variant of a type held as a value, holding a value in a case by a name
+ * held as a value — what `variant(name, value)` builds where the case is
+ * written. A recursive type's node is built, and wrapped in it.
+ *
+ * @typeParam T - The variant's type
+ * @param type - A variant type, or a recursive type whose node is one
+ * @param name - The case
+ * @param value - Its value or expression
+ * @returns The variant's expression
+ * @throws {Error} When the type is not a variant, has no case of the name, or the value is not of the case's type
+ */
+export function inCase(type, name, value) {
+    const node = type.type === "Recursive" ? type.node : type;
+    if (node.type !== "Variant")
+        throw new Error(`East.inCase: ${words(type)} is not a variant`);
+    if (!(name in node.cases))
+        throw new Error(`East.inCase: ${words(node)} has no case '${name}'`);
+    const built = from(variant(name, value), node);
+    return (type.type === "Recursive" ? wrapRecursive(built, type) : built);
+}
+/**
+ * The patch functions of a type held as a value: diff, apply, compose and
+ * invert, each an East function of the type — what `East.diff`,
+ * `East.applyPatch`, `East.composePatch` and `East.invertPatch` build where
+ * the type is written, and the program side of `diffFor`.
+ *
+ * @typeParam T - The type patched
+ * @param type - The type
+ * @returns Its patch type and its patch functions
+ */
+export function patchesFor(type) {
+    // From the type's runtime form: a type known only as a value has a patch TypeScript cannot compute.
+    const patchType = PatchType(toEastTypeValue(type));
+    // Built over the type as an East type: the functions' own signatures are the ones declared.
+    const valueType = type;
+    return {
+        patchType,
+        diff: func([valueType, valueType], patchType, (_$, before, after) => builtin("Diff", [valueType, patchType], [before, after], patchType)),
+        apply: func([valueType, patchType], valueType, (_$, value, patch) => builtin("ApplyPatch", [valueType, patchType], [value, patch], valueType)),
+        compose: func([patchType, patchType], patchType, (_$, first, second) => builtin("ComposePatch", [valueType, patchType], [first, second], patchType)),
+        invert: func([patchType], patchType, (_$, patch) => builtin("InvertPatch", [valueType, patchType], [patch], patchType)),
+    };
+}
+//# sourceMappingURL=named.js.map

package/dist/src/expr/named.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"named.js","sourceRoot":"","sources":["../../../src/expr/named.ts"],"names":[],"mappings":"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"}