@fncts/schema 0.0.5 → 0.0.6

package/_src/Parser/interpreter.ts

@@ -0,0 +1,442 @@
+import type { Literal } from "../AST.js";
+import type { Hook } from "../ASTAnnotation.js";
+import type { MutableVector } from "@fncts/base/collection/immutable/Vector";
+import type { Validation } from "@fncts/base/data/Branded";
+
+import {
+  isBigInt,
+  isBoolean,
+  isNumber,
+  isObject,
+  isRecord,
+  isString,
+  isSymbol,
+  isUndefined,
+} from "@fncts/base/util/predicates";
+
+import { ASTTag, concrete } from "../AST.js";
+import { getKeysForIndexSignature, getTemplateLiteralRegex, memoize, ownKeys } from "../utils.js";
+
+const go = memoize(function go(ast: AST): Parser<any> {
+  concrete(ast);
+  switch (ast._tag) {
+    case ASTTag.Declaration:
+      return Parser.make(ast.decode(...ast.typeParameters));
+    case ASTTag.Literal:
+      return Parser.fromRefinement(ast, (u): u is typeof ast.literal => u === ast.literal);
+    case ASTTag.UniqueSymbol:
+      return Parser.fromRefinement(ast, (u): u is typeof ast.symbol => u === ast.symbol);
+    case ASTTag.UndefinedKeyword:
+    case ASTTag.VoidKeyword:
+      return Parser.fromRefinement(ast, isUndefined);
+    case ASTTag.NeverKeyword:
+      return Parser.fromRefinement<any>(ast, (_): _ is never => false);
+    case ASTTag.UnknownKeyword:
+    case ASTTag.AnyKeyword:
+      return Parser.make(ParseResult.succeed);
+    case ASTTag.StringKeyword:
+      return Parser.fromRefinement(ast, isString);
+    case ASTTag.NumberKeyword:
+      return Parser.fromRefinement(ast, isNumber);
+    case ASTTag.BooleanKeyword:
+      return Parser.fromRefinement(ast, isBoolean);
+    case ASTTag.BigIntKeyword:
+      return Parser.fromRefinement(ast, isBigInt);
+    case ASTTag.SymbolKeyword:
+      return Parser.fromRefinement(ast, isSymbol);
+    case ASTTag.ObjectKeyword:
+      return Parser.fromRefinement(ast, isObject);
+    case ASTTag.Enum:
+      return Parser.fromRefinement(ast, (u): u is any => ast.enums.some(([_, value]) => value === u));
+    case ASTTag.TemplateLiteral: {
+      const regex = getTemplateLiteralRegex(ast);
+      return Parser.fromRefinement(ast, (u): u is any => isString(u) && regex.test(u));
+    }
+    case ASTTag.Tuple: {
+      const elements = ast.elements.map((e) => go(e.type));
+      const rest     = ast.rest.map((rest) => rest.map(go));
+      return Parser.make((input, options) => {
+        if (!Array.isArray(input)) {
+          return ParseResult.fail(ParseError.TypeError(unknownArray, input));
+        }
+        const output: Array<any>                = [];
+        const errors: MutableVector<ParseError> = Vector.emptyPushable();
+        const allErrors = options?.allErrors;
+        let i           = 0;
+        for (; i < elements.length; i++) {
+          if (input.length < i + i) {
+            if (!ast.elements[i]!.isOptional) {
+              const e = ParseError.IndexError(i, Vector(ParseError.MissingError));
+              errors.push(e);
+              if (allErrors) {
+                continue;
+              } else {
+                return ParseResult.failures(errors);
+              }
+            } else {
+              const parser = elements[i]!;
+              const t      = parser(input[i], options);
+              Either.concrete(t);
+              if (t.isLeft()) {
+                const e = ParseError.IndexError(i, t.left);
+                errors.push(e);
+                if (allErrors) {
+                  continue;
+                } else {
+                  return ParseResult.failures(errors);
+                }
+              }
+              output.push(t.right);
+            }
+          }
+        }
+        if (rest.isJust()) {
+          const head = rest.value.unsafeHead!;
+          const tail = rest.value.tail;
+          for (; i < input.length - tail.length; i++) {
+            const t = head(input[i], options);
+            Either.concrete(t);
+            if (t.isLeft()) {
+              const e = ParseError.IndexError(i, t.left);
+              errors.push(e);
+              if (allErrors) {
+                continue;
+              } else {
+                return ParseResult.failures(errors);
+              }
+            }
+            output.push(t.right);
+          }
+          for (let j = 0; j < tail.length; j++) {
+            i += j;
+            if (input.length < i + 1) {
+              errors.push(ParseError.IndexError(i, Vector(ParseError.MissingError)));
+              return ParseResult.failures(errors);
+            } else {
+              const t = tail[j]!(input[i], options);
+              Either.concrete(t);
+              if (t.isLeft()) {
+                const e = ParseError.IndexError(i, t.left);
+                errors.push(e);
+                if (allErrors) {
+                  continue;
+                } else {
+                  return ParseResult.failures(errors);
+                }
+              }
+              output.push(t.right);
+            }
+          }
+        } else {
+          const isUnexpectedAllowed = options?.isUnexpectedAllowed;
+          for (; i < input.length; i++) {
+            const e = ParseError.IndexError(i, Vector(ParseError.UnexpectedError(input[i])));
+            if (!isUnexpectedAllowed) {
+              errors.push(e);
+              if (allErrors) {
+                continue;
+              } else {
+                return ParseResult.failures(errors);
+              }
+            }
+          }
+        }
+        return errors.isNonEmpty() ? ParseResult.failures(errors) : ParseResult.succeed(output);
+      });
+    }
+    case ASTTag.TypeLiteral: {
+      if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0) {
+        return Parser.fromRefinement(ast, (u): u is Exclude<typeof u, null> => u !== null);
+      }
+      const propertySignatureTypes = ast.propertySignatures.map((f) => go(f.type));
+      const indexSignatures        = ast.indexSignatures.map((is) => [go(is.parameter), go(is.type)] as const);
+      return Parser.make((input, options) => {
+        if (!isRecord(input)) {
+          return ParseResult.fail(ParseError.TypeError(unknownRecord, input));
+        }
+        const output: any                       = {};
+        const expectedKeys: any                 = {};
+        const errors: MutableVector<ParseError> = Vector.emptyPushable();
+        const allErrors = options?.allErrors;
+
+        for (let i = 0; i < propertySignatureTypes.length; i++) {
+          const ps           = ast.propertySignatures[i]!;
+          const parser       = propertySignatureTypes[i]!;
+          const name         = ps.name;
+          expectedKeys[name] = null;
+          if (!Object.prototype.hasOwnProperty.call(input, name)) {
+            if (!ps.isOptional) {
+              const e = ParseError.KeyError(AST.createKey(name), name, Vector(ParseError.MissingError));
+              errors.push(e);
+              if (allErrors) {
+                continue;
+              } else {
+                return ParseResult.failures(errors);
+              }
+            }
+          } else {
+            const t: ParseResult<unknown> = parser(input[name], options);
+            Either.concrete(t);
+            if (t.isLeft()) {
+              const e = ParseError.KeyError(AST.createKey(name), name, t.left);
+              errors.push(e);
+              if (allErrors) {
+                continue;
+              } else {
+                return ParseResult.failures(errors);
+              }
+            }
+            output[name] = t.right;
+          }
+        }
+
+        if (indexSignatures.length > 0) {
+          for (let i = 0; i < indexSignatures.length; i++) {
+            const [parameter, type] = indexSignatures[i]!;
+            const keys              = getKeysForIndexSignature(input, ast.indexSignatures[i]!.parameter);
+            for (const key of keys) {
+              if (Object.prototype.hasOwnProperty.call(expectedKeys, key)) {
+                continue;
+              }
+
+              let t = parameter(key, options);
+              Either.concrete(t);
+              if (t.isLeft()) {
+                const e = ParseError.KeyError(AST.createKey(key), key, t.left);
+                errors.push(e);
+                if (allErrors) {
+                  continue;
+                } else {
+                  return ParseResult.failures(errors);
+                }
+              }
+
+              t = type(input[key], options);
+              Either.concrete(t);
+              if (t.isLeft()) {
+                const e = ParseError.KeyError(AST.createKey(key), key, t.left);
+                errors.push(e);
+                if (allErrors) {
+                  continue;
+                } else {
+                  return ParseResult.failures(errors);
+                }
+              }
+
+              output[key] = t.right;
+            }
+          }
+        } else {
+          const isUnexpectedAllowed = options?.isUnexpectedAllowed;
+          for (const key of ownKeys(input)) {
+            if (!Object.prototype.hasOwnProperty.call(expectedKeys, key)) {
+              const e = ParseError.KeyError(AST.createKey(key), key, Vector(ParseError.UnexpectedError(input[key])));
+              if (!isUnexpectedAllowed) {
+                errors.push(e);
+                if (allErrors) {
+                  continue;
+                } else {
+                  return ParseResult.failures(errors);
+                }
+              }
+            }
+          }
+        }
+
+        return errors.isNonEmpty() ? ParseResult.failures(errors) : ParseResult.succeed(output);
+      });
+    }
+    case ASTTag.Union: {
+      const searchTree = getSearchTree(ast.types);
+      const ownKeys    = Reflect.ownKeys(searchTree.keys);
+      const len        = ownKeys.length;
+      const otherwise  = searchTree.otherwise;
+      const map        = new Map<any, Parser<any>>();
+      ast.types.forEach((ast) => {
+        map.set(ast, go(ast));
+      });
+      return Parser.make((input, options) => {
+        const errors = Vector.emptyPushable<ParseError>();
+        if (len > 0) {
+          if (isRecord(input)) {
+            for (let i = 0; i < len; i++) {
+              const name    = ownKeys[i]!;
+              const buckets = searchTree.keys[name]!.buckets;
+              if (Object.prototype.hasOwnProperty.call(input, name)) {
+                const literal = String(input[name]);
+                if (Object.prototype.hasOwnProperty.call(buckets, literal)) {
+                  const bucket: ReadonlyArray<AST> = buckets[literal]!;
+                  for (let i = 0; i < bucket.length; i++) {
+                    const t = map.get(bucket[i])!(input, options);
+                    Either.concrete(t);
+                    if (t.isRight()) {
+                      return t;
+                    } else {
+                      errors.push(ParseError.UnionMemberError(t.left));
+                    }
+                  }
+                } else {
+                  errors.push(
+                    ParseError.KeyError(
+                      AST.createKey(name),
+                      name,
+                      Vector(ParseError.TypeError(searchTree.keys[name]!.ast, input[name])),
+                    ),
+                  );
+                }
+              } else {
+                errors.push(ParseError.KeyError(AST.createKey(name), name, Vector(ParseError.MissingError)));
+              }
+            }
+          } else {
+            errors.push(ParseError.TypeError(unknownRecord, input));
+          }
+        }
+        for (let i = 0; i < otherwise.length; i++) {
+          const t = map.get(otherwise[i])!(input, options);
+          Either.concrete(t);
+          if (t.isRight()) {
+            return t;
+          } else {
+            errors.push(ParseError.UnionMemberError(t.left));
+          }
+        }
+
+        return errors.isNonEmpty()
+          ? ParseResult.failures(errors)
+          : ParseResult.fail(ParseError.TypeError(AST.neverKeyword, input));
+      });
+    }
+    case ASTTag.Lazy: {
+      const f   = () => go(ast.getAST());
+      const get = memoize<void, Parser<any>>(f);
+      return Parser.make((a, options) => get()(a, options));
+    }
+    case ASTTag.Refinement: {
+      const from = go(ast.from);
+      if (ast.isReversed) {
+        const to = go(ast.from.getTo);
+        return Parser.make((input, options) =>
+          to(input, options)
+            .flatMap((a) => ast.decode(a, options))
+            .flatMap((a) => from(a, options)),
+        );
+      }
+      return Parser.make((input, options) => from(input, options).flatMap((a) => ast.decode(a, options)));
+    }
+    case ASTTag.Transform: {
+      const from = go(ast.from);
+      if (ast.isReversed) {
+        const to = go(ast.to);
+        return Parser.make((input, options) =>
+          to(input, options)
+            .flatMap((a) => ast.encode(a, options))
+            .flatMap((a) => from(a, options)),
+        );
+      }
+      return Parser.make((input, options) => from(input, options).flatMap((a) => ast.decode(a, options)));
+    }
+    case ASTTag.Validation: {
+      return Parser.make((u, options) => {
+        const missedBrands = Vector.emptyPushable<Validation<any, string>>();
+        const allErrors    = options?.allErrors;
+        for (const validation of ast.validation) {
+          if (!validation.validate(u)) {
+            missedBrands.push(validation);
+            if (allErrors) {
+              continue;
+            } else {
+              return ParseResult.fail(
+                ParseError.TypeError(AST.createValidation(ast.from, missedBrands, ast.annotations), u),
+              );
+            }
+          }
+        }
+        return missedBrands.length > 0
+          ? ParseResult.fail(ParseError.TypeError(AST.createValidation(ast.from, missedBrands, ast.annotations), u))
+          : ParseResult.succeed(u);
+      });
+    }
+  }
+});
+
+export function parserFor(ast: AST): Parser<any> {
+  return go(ast);
+}
+
+const unknownArray = AST.createTuple(Vector.empty(), Just(Vector(AST.unknownKeyword)), true);
+
+const unknownRecord = AST.createTypeLiteral(
+  Vector.empty(),
+  Vector(
+    AST.createIndexSignature(AST.stringKeyword, AST.unknownKeyword, true),
+    AST.createIndexSignature(AST.symbolKeyword, AST.unknownKeyword, true),
+  ),
+);
+
+function getLiterals(ast: AST): ReadonlyArray<[PropertyKey, Literal]> {
+  AST.concrete(ast);
+  switch (ast._tag) {
+    case ASTTag.Declaration:
+      return getLiterals(ast.type);
+    case ASTTag.TypeLiteral: {
+      const out: Array<[PropertyKey, Literal]> = [];
+      for (let i = 0; i < ast.propertySignatures.length; i++) {
+        const propertySignature = ast.propertySignatures[i]!;
+        if (propertySignature.type.isLiteral() && !propertySignature.isOptional) {
+          out.push([propertySignature.name, propertySignature.type]);
+        }
+      }
+      return out;
+    }
+    case ASTTag.Refinement:
+      return getLiterals(ast.from);
+    case ASTTag.Transform:
+      return ast.isReversed ? getLiterals(ast.to) : getLiterals(ast.from.getFrom);
+  }
+  return [];
+}
+
+function getSearchTree(members: Vector<AST>): {
+  keys: {
+    readonly [key: PropertyKey]: {
+      buckets: { [literal: string]: ReadonlyArray<AST> };
+      ast: AST;
+    };
+  };
+  otherwise: ReadonlyArray<AST>;
+} {
+  const keys: {
+    [key: PropertyKey]: {
+      buckets: { [literal: string]: Array<AST> };
+      ast: AST;
+    };
+  } = {};
+  const otherwise: Array<AST> = [];
+  for (let i = 0; i < members.length; i++) {
+    const member = members[i]!;
+    const tags   = getLiterals(member);
+    if (tags.length > 0) {
+      for (let j = 0; j < tags.length; j++) {
+        const [key, literal] = tags[j]!;
+        const hash           = String(literal.literal);
+        keys[key]!         ||= { buckets: {}, ast: AST.neverKeyword };
+        const buckets        = keys[key]!.buckets;
+        if (Object.prototype.hasOwnProperty.call(buckets, hash)) {
+          if (j < tags.length - 1) {
+            continue;
+          }
+          buckets[hash]!.push(member);
+          keys[key]!.ast = AST.createUnion(Vector(keys[key]!.ast, literal));
+        } else {
+          buckets[hash]! = [member];
+          keys[key]!.ast = AST.createUnion(Vector(keys[key]!.ast, literal));
+          break;
+        }
+      }
+    } else {
+      otherwise.push(member);
+    }
+  }
+  return { keys, otherwise };
+}

package/_src/Parser.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./Parser/*.ts }
+export * from "./Parser/definition.js";
+export * from "./Parser/interpreter.js";
+// codegen:end

package/_src/Schema/api/conc.ts

@@ -0,0 +1,78 @@
+import type { Sized } from "@fncts/test/control/Sized";
+
+import { ConcTypeId } from "@fncts/base/collection/immutable/Conc";
+
+export function conc<A>(value: Schema<A>): Schema<Conc<A>> {
+  return Schema.declaration(
+    Vector(value),
+    inline(value),
+    concParser,
+    ASTAnnotationMap.empty.annotate(ASTAnnotation.Identifier, "Conc").annotate(ASTAnnotation.GenHook, gen),
+  );
+}
+
+/**
+ * @tsplus static fncts.schema.SchemaOps concFromArray
+ */
+export function concFromArray<A>(value: Schema<A>): Schema<Conc<A>> {
+  return Schema.array(value).transform(
+    conc(value),
+    (input) => Conc.fromArray(input),
+    (input) => input.toArray,
+  );
+}
+
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.Conc]<_> 10
+ */
+export function deriveConc<A extends Conc<any>>(
+  ...[value]: [A] extends [Conc<infer _A>]
+    ? Check<Check.IsEqual<A, Conc<_A>>> extends Check.True
+      ? [value: Schema<_A>]
+      : never
+    : never
+): Schema<A> {
+  return unsafeCoerce(concFromArray(value));
+}
+
+export function concParser<A>(value: Schema<A>): Parser<Conc<A>> {
+  const schema = conc(value);
+  return Parser.make((u, options) => {
+    if (!Conc.is(u)) {
+      return ParseResult.fail(ParseError.TypeError(schema.ast, u));
+    }
+    const allErrors     = options?.allErrors;
+    const errors        = Vector.emptyPushable<ParseError>();
+    const out: Array<A> = [];
+    let i               = 0;
+    for (const v of u) {
+      const t = value.decode(u);
+      Either.concrete(t);
+      if (t.isLeft()) {
+        errors.push(ParseError.IndexError(i, t.left));
+        if (!allErrors) {
+          return ParseResult.failures(errors);
+        }
+      } else {
+        out.push(t.right);
+      }
+      i++;
+    }
+    return errors.isNonEmpty() ? ParseResult.failures(errors) : ParseResult.succeed(Conc.fromArray(out));
+  });
+}
+
+function inline<A>(_value: Schema<A>): Schema<Conc<A>> {
+  return Schema.struct({
+    _A: Schema.any,
+    [ConcTypeId]: Schema.uniqueSymbol(ConcTypeId),
+    length: Schema.number,
+    [Symbol.iterator]: Schema.any,
+    [Symbol.hash]: Schema.any,
+    [Symbol.equals]: Schema.any,
+  });
+}
+
+function gen<A>(value: Gen<Sized, A>): Gen<Sized, Conc<A>> {
+  return Gen.conc(value);
+}

package/_src/Schema/api/hashMap.ts

@@ -0,0 +1,184 @@
+import type {
+  ArrayNode,
+  CollisionNode,
+  EmptyNode,
+  IndexedNode,
+  LeafNode,
+} from "@fncts/base/collection/immutable/HashMap/internal";
+import type { Node } from "@fncts/base/collection/immutable/HashMap/internal";
+import type { Sized } from "@fncts/test/control/Sized";
+import type { Check } from "@fncts/typelevel";
+
+import { HashMap } from "@fncts/base/collection/immutable/HashMap";
+import { HashMapTypeId, HashMapVariance } from "@fncts/base/collection/immutable/HashMap";
+import { ASTAnnotation } from "@fncts/schema/ASTAnnotation";
+
+/**
+ * @tsplus static fncts.schema.SchemaOps hashMap
+ */
+export function hashMap<K, V>(key: Schema<K>, value: Schema<V>): Schema<HashMap<K, V>> {
+  return Schema.declaration(
+    Vector(key, value),
+    inline(key, value),
+    hashMapParser,
+    ASTAnnotationMap.empty.annotate(ASTAnnotation.Identifier, "HashMap").annotate(ASTAnnotation.GenHook, gen),
+  );
+}
+
+/**
+ * @tsplus static fncts.schema.SchemaOps hashMapFromRecord
+ */
+export function hashMapFromRecord<K extends string | symbol, V>(
+  key: Schema<K>,
+  value: Schema<V>,
+): Schema<HashMap<K, V>> {
+  return Schema.record(key, value).transform(
+    hashMap(key, value),
+    (input) => {
+      const out = HashMap.empty<K, V>().beginMutation;
+      for (const [k, v] of Object.entries(input)) {
+        out.set(k as K, v as V);
+      }
+      return out.endMutation;
+    },
+    (input) => {
+      const out = {} as Record<K, V>;
+      input.forEachWithIndex((k, v) => {
+        out[k] = v;
+      });
+      return out;
+    },
+  );
+}
+
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.HashMap]<_> 10
+ */
+export function deriveHashMap<A extends HashMap<any, any>>(
+  // @ts-expect-error
+  ...[key, value]: [A] extends [HashMap<infer K, infer V>]
+    ? Check<Check.IsEqual<A, HashMap<K, V>> & Check.Extends<K, string | symbol>> extends Check.True
+      ? [key: Schema<K>, value: Schema<V>]
+      : never
+    : never
+): Schema<A> {
+  return unsafeCoerce(hashMapFromRecord(key as Schema<string | symbol>, value));
+}
+
+function hashMapParser<K, V>(key: Schema<K>, value: Schema<V>): Parser<HashMap<K, V>> {
+  const schema = hashMap(key, value);
+  return Parser.make((u, options) => {
+    if (!HashMap.is(u)) {
+      return ParseResult.fail(ParseError.TypeError(schema.ast, u));
+    }
+    const allErrors = options?.allErrors;
+    const errors    = Vector.emptyPushable<ParseError>();
+    const out       = HashMap.empty<K, V>().beginMutation;
+    for (const [k, v] of u) {
+      const tk = key.decode(k, options);
+      Either.concrete(tk);
+      if (tk.isLeft()) {
+        errors.push(ParseError.KeyError(key.ast, k, tk.left));
+        if (!allErrors) {
+          return ParseResult.failures(errors);
+        }
+      }
+      const tv = value.decode(v, options);
+      Either.concrete(tv);
+      if (tv.isLeft()) {
+        errors.push(ParseError.KeyError(key.ast, k, tv.left));
+        if (!allErrors) {
+          return ParseResult.failures(errors);
+        }
+      }
+      if (tk.isLeft() || tv.isLeft()) {
+        continue;
+      }
+      out.set(tk.right, tv.right);
+    }
+    return errors.isNonEmpty() ? ParseResult.failures(errors) : ParseResult.succeed(out.endMutation);
+  });
+}
+
+function emptyNodeSchema<K, V>(_key: Schema<K>, _value: Schema<V>): Schema<EmptyNode<K, V>> {
+  return Schema.struct({
+    _tag: Schema.literal("EmptyNode"),
+    modify: Schema.any,
+  });
+}
+
+function leafNodeSchema<K, V>(key: Schema<K>, value: Schema<V>): Schema<LeafNode<K, V>> {
+  return Schema.struct({
+    _tag: Schema.literal("LeafNode"),
+    edit: Schema.number,
+    hash: Schema.number,
+    key,
+    value: value.maybe,
+    modify: Schema.any,
+  });
+}
+
+function collisionNodeSchema<K, V>(key: Schema<K>, value: Schema<V>): Schema<CollisionNode<K, V>> {
+  return Schema.lazy(() =>
+    Schema.struct({
+      _tag: Schema.literal("CollisionNode"),
+      edit: Schema.number,
+      hash: Schema.number,
+      children: nodeSchema(key, value).mutableArray,
+      modify: Schema.any,
+    }),
+  );
+}
+
+function indexedNodeSchema<K, V>(key: Schema<K>, value: Schema<V>): Schema<IndexedNode<K, V>> {
+  return Schema.lazy(() =>
+    Schema.struct({
+      _tag: Schema.literal("IndexedNode"),
+      edit: Schema.number,
+      mask: Schema.number,
+      children: nodeSchema(key, value).mutableArray,
+      modify: Schema.any,
+    }),
+  );
+}
+
+function arrayNodeSchema<K, V>(key: Schema<K>, value: Schema<V>): Schema<ArrayNode<K, V>> {
+  return Schema.lazy(() =>
+    Schema.struct({
+      _tag: Schema.literal("ArrayNode"),
+      edit: Schema.number,
+      size: Schema.number,
+      children: nodeSchema(key, value).mutableArray,
+      modify: Schema.any,
+    }),
+  );
+}
+
+function nodeSchema<K, V>(key: Schema<K>, value: Schema<V>): Schema<Node<K, V>> {
+  return Schema.union(
+    emptyNodeSchema(key, value),
+    leafNodeSchema(key, value),
+    collisionNodeSchema(key, value),
+    indexedNodeSchema(key, value),
+    arrayNodeSchema(key, value),
+  );
+}
+
+function inline<K, V>(key: Schema<K>, value: Schema<V>): Schema<HashMap<K, V>> {
+  return Schema.struct({
+    [HashMapTypeId]: Schema.uniqueSymbol(HashMapTypeId),
+    [HashMapVariance]: Schema.any,
+    editable: Schema.boolean,
+    edit: Schema.number,
+    config: Schema.any,
+    root: nodeSchema(key, value),
+    size: Schema.number,
+    [Symbol.iterator]: Schema.any,
+    [Symbol.hash]: Schema.any,
+    [Symbol.equals]: Schema.any,
+  });
+}
+
+function gen<K, V>(key: Gen<Sized, K>, value: Gen<Sized, V>): Gen<Sized, HashMap<K, V>> {
+  return Gen.array(Gen.tuple(key, value)).map((pairs) => HashMap.from(pairs));
+}