gdp-wired 0.3.0 → 0.5.0

package/dist/core/dsl.d.ts

@@ -4,7 +4,8 @@ export type TermLike = Term | number;
 export declare const termOf: (t: TermLike) => E;
 export declare class Term {
     readonly e: E;
-    constructor(e: E);
+    readonly val?: number | undefined;
+    constructor(e: E, val?: number | undefined);
     plus(b: TermLike): Term;
     minus(b: TermLike): Term;
     times(k: number): Term;
@@ -18,7 +19,8 @@ export declare class Term {
 }
 export declare class Cond {
     readonly c: C;
-    constructor(c: C);
+    readonly ok?: boolean | undefined;
+    constructor(c: C, ok?: boolean | undefined);
     and(...xs: Cond[]): Cond;
     or(...xs: Cond[]): Cond;
     not(): Cond;
@@ -33,19 +35,79 @@ export declare const any: (...cs: Cond[]) => Cond;
 export declare const not: (c: Cond) => Cond;
 export declare const min: (a: TermLike, b: TermLike) => Term;
 export declare const max: (a: TermLike, b: TermLike) => Term;
-export declare const when: (c: Cond, then: TermLike, otherwise: TermLike) => Term;
+export declare function when(c: Cond, then: TermLike, otherwise: TermLike): Term;
+export declare function when(c: Cond, then: Decimal, otherwise: Decimal | number): Decimal;
+export declare function when(c: Cond, then: Decimal | number, otherwise: Decimal): Decimal;
+export declare function when(c: Cond, then: IntLike, otherwise: IntLike): Int;
+export declare function when<K extends string>(c: Cond, then: Choice<K>, otherwise: Choice<K>): Choice<K>;
+export declare function when(c: Cond, then: Str, otherwise: Str): Str;
+export declare function when<V>(c: Cond, then: Maybe<V>, otherwise: Maybe<V>): Maybe<V>;
+export declare function when(c: Cond, then: Cond, otherwise: Cond): Cond;
 export declare const choose: (c: Cond, then: Cond, otherwise: Cond) => Cond;
 export declare const count: (c: Cond) => Term;
 export declare const sum: (first: TermLike, ...rest: TermLike[]) => Term;
 type Rand = (k: number) => number;
 type Raw = number | boolean | string | null | undefined;
+export type At = string | ((name: string) => string);
+export type Init<V> = {
+    readonly kind: Kind<V>;
+    readonly init: Raw | ((p: never) => unknown);
+};
 export declare abstract class Kind<V> {
     readonly _value: V;
     abstract vars(name: string): string[];
     abstract assume(name: string): Cond[];
-    abstract value(name: string, prefix?: string): V;
+    abstract value(name: string, at?: At): V;
     abstract encode(name: string, raw: Raw): Record<string, number>;
     abstract random(name: string, rand: Rand, bound: number): Record<string, number>;
+    abstract store(name: string, value: unknown): Record<string, TermLike>;
+    abstract decode(name: string, vars: Record<string, number>): Raw;
+    abstract empty(): Raw;
+    sample(_rand: Rand, _bound: number): Raw;
+    from(init: Raw | ((p: never) => unknown)): Init<V>;
+}
+export type IntLike = Int | Term | number;
+export declare class Int {
+    readonly pos: Term;
+    readonly neg: Term;
+    constructor(pos: Term, neg: Term);
+    static of(x: IntLike): Int;
+    plus(b: IntLike): Int;
+    minus(b: IntLike): Int;
+    negate(): Int;
+    times(k: number): Int;
+    lt(b: IntLike): Cond;
+    atMost(b: IntLike): Cond;
+    gt(b: IntLike): Cond;
+    atLeast(b: IntLike): Cond;
+    eq(b: IntLike): Cond;
+    ne(b: IntLike): Cond;
+    min(b: IntLike): Int;
+    max(b: IntLike): Int;
+    get isNegative(): Cond;
+    get abs(): Term;
+    get clamped(): Term;
+}
+export type DecimalLike = Decimal | IntLike;
+export declare class Decimal {
+    readonly int: Int;
+    readonly places: number;
+    constructor(int: Int, places: number);
+    lift(b: DecimalLike): Int;
+    private with;
+    plus(b: DecimalLike): Decimal;
+    minus(b: DecimalLike): Decimal;
+    negate(): Decimal;
+    times(k: number): Decimal;
+    lt(b: DecimalLike): Cond;
+    atMost(b: DecimalLike): Cond;
+    gt(b: DecimalLike): Cond;
+    atLeast(b: DecimalLike): Cond;
+    eq(b: DecimalLike): Cond;
+    ne(b: DecimalLike): Cond;
+    min(b: DecimalLike): Decimal;
+    max(b: DecimalLike): Decimal;
+    get isNegative(): Cond;
 }
 export declare const nat: Kind<Term>;
 export declare const upTo: (maxValue: number) => Kind<Term>;
@@ -68,8 +130,8 @@ export declare class Choice<K extends string> {
 }
 export declare const oneOf: <const K extends string>(...values: K[]) => Kind<Choice<K>>;
 export declare class Maybe<V> {
-    private readonly present;
-    private readonly inner;
+    readonly present: Term;
+    readonly inner: V;
     constructor(present: Term, inner: V);
     get isSome(): Cond;
     get isNone(): Cond;
@@ -83,20 +145,52 @@ export declare class Maybe<V> {
     }): Term;
 }
 export declare const maybe: <V>(of: Kind<V>) => Kind<Maybe<V>>;
+export declare const intern: ((text: string) => number) & {
+    load(entries: [string, number][]): void;
+};
+export declare const interned: () => [string, number][];
+export declare const globMatch: (pattern: string, text: string) => boolean;
+export declare class Str {
+    readonly id: Term;
+    readonly length: Term;
+    private readonly bits;
+    constructor(id: Term, length: Term, bits: ReadonlyMap<string, Term>);
+    get patterns(): string[];
+    choose(c: Cond, other: Str): Str;
+    like(pattern: string): Cond;
+    get isEmpty(): Cond;
+    bit(pattern: string): Term;
+    eq(b: Str | string): Cond;
+    ne(b: Str | string): Cond;
+}
+export declare const str: (opts?: {
+    like?: readonly string[];
+    maxLength?: number;
+}) => Kind<Str>;
+export declare const int: Kind<Int>;
+export declare const decimal: (places: number) => Kind<Decimal>;
 export type MapWrite = {
     readonly map: string;
     readonly key: E;
     readonly value: E;
+    readonly concrete?: {
+        key?: number;
+        value?: number;
+    };
 } | {
     readonly map: string;
     readonly each: string;
     readonly value: E;
+    readonly concrete?: {
+        at: (key: Term) => TermLike;
+    };
 };
 export declare const everyKey: (f: (key: Term) => Cond) => Cond;
 export declare const someKey: (f: (key: Term) => Cond, witness?: TermLike) => Cond;
 export declare class MapRef {
     readonly name: string;
     readonly init: number;
+    private readonly cells;
     constructor(name: string, init: number);
     at(key: TermLike): Term;
     set(key: TermLike, value: TermLike): MapWrite;
@@ -117,6 +211,7 @@ export type ListOp = {
 export declare class ListRef {
     readonly name: string;
     readonly len: Term;
+    private readonly cells;
     constructor(name: string, len: Term);
     at(i: TermLike): Term;
     has(x: TermLike): Cond;
@@ -157,8 +252,9 @@ type ValuesOf<K extends Kinds> = {
     [n in keyof K]: K[n] extends Kind<infer V> ? V : never;
 };
 type Obj = object;
+type Writes<V> = V extends Decimal ? DecimalLike | string : V extends Int ? IntLike : V extends Cond ? Cond | boolean : V extends Choice<infer K> ? Choice<K> | K : V extends Maybe<infer W> ? Maybe<W> | Writes<W> | null : V extends Str ? Str | string : TermLike;
 type Update<S extends Obj, M extends Obj> = Partial<{
-    [k in keyof S]: TermLike;
+    [k in keyof S]: Writes<S[k]>;
 } & {
     [k in keyof M]: MapWrite;
 }>;
@@ -169,6 +265,7 @@ type Spec = {
     state: [string, number | ((p: never) => TermLike)][];
     maps: [string, number][];
     lists?: string[];
+    kinded?: [string, Kind<unknown>][];
     carried?: string[];
     fns?: [string, FnDef][];
     facts?: ((env: never) => Record<string, Cond | Forall>)[];
@@ -193,12 +290,18 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
     get name(): string;
     params<K extends Kinds>(kinds: K): Rule<P & ValuesOf<K>, I, S, M, F, R, Su, Q>;
     inputs<K extends Kinds>(kinds: K): Rule<P, I & ValuesOf<K>, S, M, F, R, Su, Q>;
-    state<T extends Record<string, number | ((p: P) => TermLike)>>(init: T): Rule<P, I, S & {
-        [k in keyof T]: Term;
+    state<T extends Record<string, number | ((p: P) => TermLike) | Init<unknown>>>(init: T): Rule<P, I, S & {
+        [k in keyof T]: T[k] extends Init<infer V> ? V : Term;
     }, M, F, R, Su, Q>;
     maps<T extends Record<string, number>>(init: T): Rule<P, I, S, M & {
         [k in keyof T]: MapRef;
     }, F, R, Su, Q>;
+    ints<T extends Record<string, number | ((p: P) => IntLike)>>(init: T): Rule<P, I, S & {
+        [k in keyof T]: Int;
+    }, M, F, R, Su, Q>;
+    decimals<T extends Record<string, number | string | ((p: P) => DecimalLike)>>(places: number, init: T): Rule<P, I, S & {
+        [k in keyof T]: Decimal;
+    }, M, F, R, Su, Q>;
     lists<const N extends string>(...names: N[]): Rule<P, I, S & {
         [k in N as `${k}_len`]: Term;
     }, M & {
@@ -241,9 +344,42 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
         }[];
     }): Liveness;
     decide(name: string, given: (env: P & I) => Cond | Cond[], then: (env: P & I) => Cond): Decision;
+    relate(name: string, given: (a: P & I, b: P & I) => Cond | Cond[], then: (a: P & I, b: P & I) => Cond): Decision;
     private kindAssumptions;
+    private afterEnv;
     private env;
+    private names;
+    private whatIs;
+    private distinct;
     get machine(): Machine;
+    crossCheck(laws: Law[], stepLaws?: StepLaw[], opts?: {
+        trials?: number;
+        depth?: number;
+        bound?: number;
+        rand?: Rand;
+    }): {
+        checked: number;
+        failure?: string;
+    };
+    private verdict;
+    private crossStep;
+    compare<St extends Record<string, number>>(reference: {
+        init: (params: {
+            [k in keyof P]: Raw;
+        }) => St;
+        step: (params: {
+            [k in keyof P]: Raw;
+        }, st: St, request: {
+            [k in keyof I]: Raw;
+        }) => St;
+    }, opts?: Draws<{
+        [k in keyof I]: Raw;
+    }> & {
+        params?: (rand: Rand) => {
+            [k in keyof P]: Raw;
+        };
+        depth?: number;
+    }): Agreement;
     encodeParams(values: {
         [k in keyof P]: Raw;
     }): Record<string, number>;
@@ -252,6 +388,7 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
     }): Request;
     randomParams(rand: Rand, bound: number): Record<string, number>;
     randomInput(rand: Rand, bound: number): Request;
+    decode(st: State): Record<string, Raw>;
     get orderedBy(): string | undefined;
     interpreter(): {
         init: (params: {
@@ -288,6 +425,61 @@ export type Decision = {
     then: C;
     goal: Goal;
 };
+type Result<T> = {
+    [k in keyof T]: T[k] extends Cond ? Cond : T[k] extends Decimal ? Decimal : T[k] extends Int ? Int : T[k] extends Choice<infer K> ? Choice<K> : T[k] extends Str ? Str : Term;
+};
+type Value<T> = {
+    [k in keyof T]: T[k] extends Cond ? boolean : T[k] extends Choice<infer K> ? K : T[k] extends Str ? string : number;
+};
+type Field = Term | Cond | Int | Decimal | Choice<string> | Str;
+export declare class Fun<P extends Obj = {}, I extends Obj = {}, O extends Obj = {}> {
+    private readonly r;
+    private readonly out?;
+    constructor(r: Rule<P, I>, out?: ((env: never) => Record<string, TermLike | Field>) | undefined);
+    get name(): string;
+    params<K extends Kinds>(kinds: K): Fun<P & ValuesOf<K>, I, O>;
+    inputs<K extends Kinds>(kinds: K): Fun<P, I & ValuesOf<K>, O>;
+    fns<T extends Record<string, FnDef>>(defs: T): Fun<P & {
+        [k in keyof T]: (...args: TermLike[]) => Term;
+    }, I, O>;
+    facts(f: (p: P) => Record<string, Cond | Forall>): Fun<P, I, O>;
+    pre(f: (p: P) => Cond): Fun<P, I, O>;
+    assume(f: (env: P & I) => Cond): Fun<P, I, O>;
+    returns<T extends Record<string, TermLike | Field>>(f: (env: P & I) => T): Fun<P, I, Result<T>>;
+    private result;
+    law(name: string, given: (env: P & I, out: O) => Cond | Cond[], then: (out: O, env: P & I) => Cond): Decision;
+    relate(name: string, given: (a: P & I, b: P & I) => Cond | Cond[], then: (outA: O, outB: O, a: P & I, b: P & I) => Cond): Decision;
+    compare(reference: (values: {
+        [k in keyof I]: Raw;
+    }, params: {
+        [k in keyof P]: Raw;
+    }) => Partial<Value<O>>, opts?: Draws<{
+        [k in keyof I]: Raw;
+    }> & {
+        params?: {
+            [k in keyof P]: Raw;
+        };
+    }): Agreement;
+    get rule(): Rule<P, I>;
+    private compiledRule?;
+    run(values: {
+        [k in keyof I]: Raw;
+    }, params?: {
+        [k in keyof P]?: Raw;
+    }): Value<O>;
+}
+export declare const fun: (name: string) => Fun;
+export type Agreement = {
+    checked: number;
+    failure?: string;
+};
+type Draws<T> = {
+    trials?: number;
+    bound?: number;
+    rand?: Rand;
+    edges?: T[];
+    draw?: (rand: Rand) => T;
+};
 export declare class LoopRule<P extends Obj = {}, I extends Obj = {}, S extends Obj = {}> {
     private readonly spec;
     constructor(spec: {
@@ -328,6 +520,7 @@ export type Verdict = {
     stuck?: string;
     goal?: string;
     witness?: Record<string, number>;
+    why?: string;
     trees?: Record<string, Tree>;
 };
 export declare function proveRule(r: Rule<Obj, Obj, Obj, Obj, Obj, Obj, Obj, Obj>, laws: Law[]): Verdict;
@@ -336,4 +529,12 @@ export type { StepLaw };
 export type { Liveness };
 export declare function proveLeadsTo(r: Rule<Obj, Obj, Obj, Obj, Obj, Obj, Obj, Obj>, laws: Law[], l: Liveness): Verdict;
 export declare const proveDecision: (d: Decision) => Verdict;
+export declare function crossCheckDecision(d: Decision, opts?: {
+    trials?: number;
+    bound?: number;
+    rand?: Rand;
+}): {
+    checked: number;
+    failure?: string;
+};
 export declare const proveLoop: (l: LoopRule<Obj, Obj, Obj>, laws: Law[]) => Verdict;