@mark1russell7/coeval 0.17.0 → 0.18.0

package/src/types.ts

@@ -66,6 +66,12 @@ export interface Domain {
    * domain does not count. The check reads a list of at most 64 values.
    */
   readonly values?: readonly unknown[];
+  /**
+   * Some members of the domain for the tests of `conforms`, for example `0` and `-1` of `number` (D99). The checks
+   * `truth` and `cover` add the samples of each domain to the palette. A sample that fails a test of a type does not
+   * count. The list is not a full list of the members, thus `fits` does not read it.
+   */
+  readonly samples?: readonly unknown[];
   /**
    * The covers of the domain (TYPE.FITS-COVER, D85). A cover is a list of domains under this domain, and its domains
    * together hold each member of this domain. An example is a domain of negative numbers and a domain of the other
@@ -73,7 +79,7 @@ export interface Domain {
    *
    * A split of a record also narrows a field of the domain to each domain of a cover (D90).
    * The language keeps each cover true, and `fits` trusts it, as it trusts `values`. A cover that is empty, or that
-   * names this domain or a name that is not under it, does not count.
+   * names this domain or a name that is not under it, does not count. `conforms` tests each cover from samples (D94).
    */
   readonly covers?: readonly (readonly string[])[];
 }
@@ -115,7 +121,7 @@ export const STD_DOMAINS: Readonly<Record<string, Domain>> = {
   // JSON has no undefined, thus a document holds it as ext.undefined (D48). The domain has no codec: the codec of values writes undefined first.
   undefined: { is: (value) => value === undefined, values: [undefined], summary: "The value undefined. A document holds it as the extension ext.undefined." },
   bool: { is: (value) => typeof value === "boolean", values: [true, false], summary: "A truth value: true or false." },
-  number: { is: (value) => typeof value === "number", summary: "A number of the host, also NaN, an infinity and -0." },
+  number: { is: (value) => typeof value === "number", samples: [0, -1], summary: "A number of the host, also NaN, an infinity and -0." },
   text: { is: (value) => typeof value === "string", summary: "A text." },
 };
 
@@ -421,7 +427,8 @@ function membersAt(type: unknown, domains: Readonly<Record<string, Domain>> | un
 /**
  * This function gives members of a type for a test of a declaration (D86). A type with at most 64 members gives each
  * member, from the lists `values` of its domains (TYPE.FITS-FINITE). A union gives the members of each of its types.
- * Each other type gives the samples that are its members. The kernel does not export the function.
+ * Each other type gives the samples that are its members. The samples of the domains come after the given samples (D99).
+ * The kernel does not export the function.
  *
  * @param type - The type.
  * @param domains - The domains of the machine.
@@ -429,7 +436,61 @@ function membersAt(type: unknown, domains: Readonly<Record<string, Domain>> | un
  * @returns Distinct members of the type.
  */
 export function membersOf(type: ValueType, domains: Readonly<Record<string, Domain>> | undefined, samples: readonly unknown[]): readonly unknown[] {
-  return membersAt(type, domains, samples, 0);
+  return membersAt(type, domains, withDomainSamples(samples, domains), 0);
+}
+
+/**
+ * This function adds the samples of the domains to a palette (D99). It reads the list `samples` of each domain of the
+ * table and of each standard domain that the table does not replace. The result holds each value one time.
+ */
+function withDomainSamples(palette: readonly unknown[], domains: Readonly<Record<string, Domain>> | undefined): readonly unknown[] {
+  const out: unknown[] = [];
+  for (const value of palette) addValue(out, value);
+  const names = new Set([...Object.keys(STD_DOMAINS), ...(domains === undefined ? [] : Object.keys(domains))]);
+  for (const name of names) {
+    const samples: unknown = domainOf(name, domains)?.samples;
+    if (Array.isArray(samples)) for (const value of samples as readonly unknown[]) addValue(out, value);
+  }
+  return out;
+}
+
+/** A false cover that a sample shows (D94): a member of a covered domain that no domain of the cover holds. */
+export interface FalseCover {
+  /** The name of the covered domain. */
+  readonly domain: string;
+  /** The cover: the names of its domains. */
+  readonly cover: readonly string[];
+  /** The sample. It is a member of the covered domain. */
+  readonly value: unknown;
+}
+
+/**
+ * This function finds the false covers of a language from samples (D94). A cover is false when a sample of the covered
+ * domain is in no domain of the cover. The function tests each valid cover of each domain of the table. It ignores a
+ * cover that does not count by the line rule of D85, because `fits` ignores it too. It also ignores a sample outside
+ * the covered domain.
+ *
+ * The samples of the domains come after the given samples (D99). `conforms` and a test of `fits` use the function. The
+ * kernel does not export it.
+ *
+ * @param domains - The domains of the language, by their names.
+ * @param samples - The samples of each covered domain, by the name of the domain.
+ * @returns Each sample that breaks a cover, in the order of the domains, the covers and the samples.
+ */
+export function falseCovers(domains: Readonly<Record<string, Domain>>, samples: Readonly<Record<string, readonly unknown[]>>): readonly FalseCover[] {
+  const out: FalseCover[] = [];
+  for (const [name, domain] of Object.entries(domains)) {
+    const covers: unknown = domain.covers;
+    if (!Array.isArray(covers)) continue;
+    const values = withDomainSamples((Object.hasOwn(samples, name) ? samples[name] : undefined) ?? [], domains);
+    for (const cover of covers as readonly unknown[]) {
+      if (!validCover(name, cover, domains)) continue;
+      for (const value of values) {
+        if (member(value, name, domains) && !cover.some((part) => member(value, part, domains))) out.push({ domain: name, cover, value });
+      }
+    }
+  }
+  return out;
 }
 
 /** This function holds the rules of the shapes of `fits`: base types, lists, records and functions. */
@@ -542,12 +603,13 @@ function partFits(part: string, expected: unknown, domains: Readonly<Record<stri
 /**
  * A field that the split rule can split: the path of keys to it, its cases, and if the field is optional. A value
  * split has the members of the field type. A type split has case types: the domains of a cover, or the members of a
- * union (TYPE.FITS-SPLIT-TYPE, D90).
+ * union (TYPE.FITS-SPLIT-TYPE, D90). A cover split has each valid cover of the field, in the order of the line (D102).
  */
 interface Split {
   readonly path: readonly string[];
   readonly values?: readonly unknown[];
   readonly types?: readonly ValueType[];
+  readonly covers?: readonly (readonly string[])[];
   readonly optional: boolean;
 }
 
@@ -563,7 +625,8 @@ interface SplitBudget {
  * cases is a split. An optional field also has the absent case.
  *
  * The type splits follow each value split, in the same order (D90). A base type with a valid cover in its line splits
- * into the domains of the cover. A union without a finite list splits into its members. The prefix is the path of `a`.
+ * into the domains of a cover, and it tries each valid cover (D102). A union without a finite list splits into its
+ * members. The prefix is the path of `a`.
  */
 function splitsOf(
   a: Extract<Form, { readonly t: "record" }>,
@@ -588,8 +651,8 @@ function splitsOf(
         if (inner.t === "record") deeper.push({ path: [...path, key], form: inner });
         else if (inner.t === "union") later.push({ path: [...path, key], types: inner.members, optional });
         else if (inner.t === "base") {
-          const cover = coverOf(inner.name, domains, false);
-          if (cover !== undefined) later.push({ path: [...path, key], types: cover, optional });
+          const covers = coversOf(inner.name, domains, false);
+          if (covers.length > 0) later.push({ path: [...path, key], covers, optional });
         }
       }
     }
@@ -604,17 +667,17 @@ function validCover(name: string, cover: unknown, domains: Readonly<Record<strin
 }
 
 /**
- * This function gives the cover of a base type for a type split (D90). The cover is the first valid cover of the first
- * domain in the line with a valid cover. With `own`, only the domain of the type itself counts. Each other type gives
- * `undefined`.
+ * This function gives the valid covers of a base type for a type split (D90, D102). The order is the order of the line,
+ * then the order of the covers of each domain. With `own`, only the domain of the type itself counts.
  */
-function coverOf(name: string, domains: Readonly<Record<string, Domain>> | undefined, own: boolean): readonly string[] | undefined {
+function coversOf(name: string, domains: Readonly<Record<string, Domain>> | undefined, own: boolean): readonly (readonly string[])[] {
+  const out: (readonly string[])[] = [];
   for (const each of own ? [name] : lineOf(name, domains)) {
     const covers: unknown = domainOf(each, domains)?.covers;
     if (!Array.isArray(covers)) continue;
-    for (const cover of covers as readonly unknown[]) if (validCover(each, cover, domains)) return cover;
+    for (const cover of covers as readonly unknown[]) if (validCover(each, cover, domains)) out.push(cover);
   }
-  return undefined;
+  return out;
 }
 
 /**
@@ -629,8 +692,8 @@ function againOf(type: ValueType, path: readonly string[], domains: Readonly<Rec
   const form = formOf(type, domains);
   if (form.t === "record") return splitsOf(form, domains, at, path);
   if (form.t === "union") return [{ path, types: form.members, optional: false }];
-  const cover = form.t === "base" ? coverOf(form.name, domains, true) : undefined;
-  return cover === undefined ? [] : [{ path, types: cover, optional: false }];
+  const covers = form.t === "base" ? coversOf(form.name, domains, true) : [];
+  return covers.length === 0 ? [] : [{ path, covers, optional: false }];
 }
 
 /**
@@ -663,6 +726,8 @@ function narrowAt(type: unknown, path: readonly string[], at: number, narrowed:
  * A record of the split that does not fit splits the next such field. A record of a type split first splits its case
  * again, at the same path. One budget of 64 records serves the outer split and each split inside its work, at each
  * depth. Thus nested splits do not multiply the work.
+ *
+ * A cover split tries each valid cover of its field until one fits (D102). Each try takes from the same budget.
  */
 function splitFits(
   found: unknown,
@@ -692,6 +757,15 @@ function casesFit(
 ): boolean {
   const split = splits[index];
   if (split === undefined) return false;
+  // A cover split tries each valid cover in its order. A failed try keeps the records that it took from the budget (D102).
+  if (split.covers !== undefined) {
+    for (const cover of split.covers) {
+      const tried = [...splits];
+      tried[index] = { path: split.path, types: cover, optional: split.optional };
+      if (casesFit(type, closed, tried, index, expected, domains, depth, gradual, budget)) return true;
+    }
+    return false;
+  }
   const types: readonly ValueType[] = split.values?.map((value) => ({ one: [value as Json] })) ?? split.types ?? [];
   const cases: ValueType[] = types.map((each) => narrowAt(type, split.path, 0, each, domains));
   if (split.optional) cases.push(narrowAt(type, split.path, 0, undefined, domains));
@@ -743,16 +817,18 @@ function casesFit(
  *   split first, then the paths of each next depth, in the order of the keys. A path goes into a record without a
  *   finite list. Thus `{a: {x: bool}}` fits the union of `{a: {x: true}}` and `{a: {x: false}}`.
  * - A type split comes after each value split (TYPE.FITS-SPLIT-TYPE, D90). A field of a base type with a valid cover in
- *   its line splits into the domains of the first such cover. A field of a union without a finite list splits into its
- *   members. A case that does not fit splits again at its path, by the same rules. A base type there uses only a
- *   cover of its own domain. Thus `{a: number}` fits `{a: neg} | {a: nonneg}` when `neg` and `nonneg` cover `number`.
+ *   its line splits into the domains of a cover. A field of a union without a finite list splits into its
+ *   members. A case that does not fit splits again at its path, by the same rules. A base type there uses only the
+ *   covers of its own domain. Thus `{a: number}` fits `{a: neg} | {a: nonneg}` when `neg` and `nonneg` cover `number`.
+ * - A field with more than one valid cover tries each cover until one fits (TYPE.FITS-SPLIT-COVERS, D102). The order
+ *   is the order of the line, then the order of the covers of each domain.
  *
  * The relation is sound: a member of `found` is a member of `expected` when no `unknown` is in the types
  * (TYPE.FITS-SOUND). The finite rule trusts `values`, and the cover rule trusts `covers`. Thus a list without a member
  * or a false cover makes the relation unsound for that domain.
  *
- * The relation is not complete. A split builds at most 64 records, with each split inside its work at each depth. A
- * type split uses one cover of a field, not each cover of its line. A domain without `values` gets no finite rule, and
+ * The relation is not complete. A split builds at most 64 records, with each split inside its work at each depth. The
+ * failed tries of covers take from these 64 records too. A domain without `values` gets no finite rule, and
  * neither does a type with more than 64 members that is not a record. The cover rule tests at most 64 domains of
  * covers. The function does not throw.
  *