gdp-wired 0.18.0 → 0.20.0

package/dist/core/data.d.ts

@@ -6,7 +6,9 @@ export declare const self: {
 };
 export declare const natural: "nat";
 export declare const boolean: "bool";
-type FieldSort = 'nat' | 'self';
+export type FieldSort = 'nat' | {
+    data: string;
+};
 export type Sort = 'nat' | 'bool' | Data;
 export type Ctor = {
     name: string;
@@ -51,6 +53,12 @@ export type X = {
         binds: string[];
         body: X;
     }[];
+} | {
+    op: 'natmatch';
+    of: X;
+    zero: X;
+    pred: string;
+    succ: X;
 } | {
     op: 'apply';
     param: string;
@@ -90,6 +98,12 @@ export declare class Nat {
     atLeast(b: NatLike): Bool;
     eq(b: NatLike): Bool;
     ne(b: NatLike): Bool;
+    match(cases: {
+        zero: () => Nat | Bool | Val | number;
+        succ: (f: {
+            pred: Nat;
+        }) => Nat | Bool | Val | number;
+    }): any;
 }
 export type NatLike = Nat | number;
 export declare class Bool {
@@ -114,20 +128,33 @@ export declare class Val {
 }
 export declare const wrap: (s: Sort, x: X) => Nat | Bool | Val;
 export declare function when<T extends Nat | Val | Bool | number>(c: Bool, a: T, b: T): T extends number ? Nat : T;
+export declare const dataNamed: (name: string) => Data;
+export declare const fieldSort: (f: {
+    sort: FieldSort;
+}) => Sort;
+export declare const inGroup: (d: Data, f: {
+    sort: FieldSort;
+}) => boolean;
 export declare class Data {
     readonly name: string;
+    readonly group: string[];
     readonly ctors: Ctor[];
-    constructor(name: string, decl: Record<string, Record<string, typeof self | 'nat' | {
-        nat: true;
-    }>>);
+    readonly seq: number;
+    constructor(name: string, decl: Record<string, Record<string, FieldSort>>, group?: string[]);
     index(ctor: string): number;
     get nullary(): number;
     make(ctor: string, ...args: (Val | NatLike)[]): Val;
+    ctorHeight(c: Ctor): number;
+    get height(): number;
 }
+export declare function weakOrder(ds: Data[]): Map<string, number>;
 type Decl = Record<string, Record<string, unknown>>;
 export declare function data<const D extends Decl>(name: string, decl: D): Data & {
     [c in keyof D]: keyof D[c] extends never ? Val : (...args: (Val | NatLike)[]) => Val;
 };
+export declare function mutual<const G extends Record<string, Decl>>(decls: G): {
+    [n in keyof G]: Data & Record<string, any>;
+};
 export type Fn = {
     name: string;
     params: {
@@ -136,7 +163,8 @@ export type Fn = {
     }[];
     ret: Sort;
     body: () => X;
-    decreases?: number;
+    readonly decreases?: number;
+    readonly ring: string[];
     paramFns: string[];
 };
 export type Callable = ((...args: (Val | NatLike | Bool)[]) => any) & {
@@ -247,9 +275,37 @@ export type Options = {
     patience?: number;
 };
 export declare function refute(l: DataLaw, n?: number, seed?: number): Record<string, string> | undefined;
+type SchemeUse = {
+    subst: Record<string, E>;
+    guard: C;
+    member?: number;
+};
+type Scheme = {
+    name: string;
+    on?: {
+        v: string;
+        d: Data | 'nat';
+    };
+    uses: SchemeUse[];
+    companions?: Companion[];
+};
+type Companion = {
+    law: DataLaw;
+    on: {
+        v: string;
+        d: Data;
+    };
+    uses: SchemeUse[];
+};
+export declare const schemesOf: (p: Program, l: DataLaw) => Scheme[];
 export declare const attemptMs: {
     ms: number;
 };
+export declare const lemmaCaps: {
+    perLemma: number;
+    total: number;
+    perCase: number;
+};
 export declare function conjectures(p: Program, l: DataLaw, max?: number, maxSize?: number): DataLaw[];
 export declare const showX: (x: X) => string;
 export declare const showY: (y: Y) => string;