@fncts/schema 0.0.16 → 0.0.18

package/_src/Schema/api/hashMap.ts

@@ -1,28 +1,17 @@
-import type {
-  ArrayNode,
-  CollisionNode,
-  EmptyNode,
-  IndexedNode,
-  LeafNode,
-  Node,
-} from "@fncts/base/collection/immutable/HashMap/internal";
+import type { KeyError } from "@fncts/schema/ParseError";
 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),
-  );
+  return Schema.declaration(Vector(key, value), hashMapParser(true), hashMapParser(false))
+    .annotate(ASTAnnotation.Identifier, `HashMap<${key.show()}, ${value.show()}>`)
+    .annotate(ASTAnnotation.GenHook, gen);
 }
 
 /**
@@ -65,118 +54,45 @@ export function deriveHashMap<A extends HashMap<any, any>>(
   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.errors));
-        if (!allErrors) {
-          return ParseResult.failures(errors);
-        }
+function hashMapParser(isDecoding: boolean) {
+  return <K, V>(key: Schema<K>, value: Schema<V>): Parser<HashMap<unknown, unknown>> => {
+    const schema = hashMap(key, value);
+    return Parser.make((u, options) => {
+      if (!HashMap.is(u)) {
+        return ParseResult.fail(ParseError.TypeError(schema.ast, u));
       }
-      const tv = value.decode(v, options);
-      Either.concrete(tv);
-      if (tv.isLeft()) {
-        errors.push(ParseError.TypeError(value.ast, tv.left));
-        if (!allErrors) {
-          return ParseResult.failures(errors);
+      const allErrors   = options?.allErrors;
+      const errors      = Vector.emptyPushable<KeyError>();
+      const out         = HashMap.empty<unknown, unknown>().beginMutation;
+      const keyParser   = isDecoding ? key.decode : key.encode;
+      const valueParser = isDecoding ? value.decode : value.encode;
+      for (const [k, v] of u) {
+        const tk = keyParser(k, options);
+        Either.concrete(tk);
+        if (tk.isLeft()) {
+          errors.push(ParseError.KeyError(key.ast, k, tk.left));
+          if (!allErrors) {
+            return ParseResult.fail(ParseError.IterableError(schema.ast, u, errors));
+          }
         }
+        const tv = valueParser(v, options);
+        Either.concrete(tv);
+        if (tv.isLeft()) {
+          errors.push(ParseError.KeyError(key.ast, k, ParseError.TypeError(value.ast, tv.left)));
+          if (!allErrors) {
+            return ParseResult.fail(ParseError.IterableError(schema.ast, u, errors));
+          }
+        }
+        if (tk.isLeft() || tv.isLeft()) {
+          continue;
+        }
+        out.set(tk.right, tv.right);
       }
-      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,
-  });
+      return errors.isNonEmpty()
+        ? ParseResult.fail(ParseError.IterableError(schema.ast, u, errors))
+        : ParseResult.succeed(out.endMutation);
+    });
+  };
 }
 
 function gen<K, V>(key: Gen<Sized, K>, value: Gen<Sized, V>): Gen<Sized, HashMap<K, V>> {

package/_src/Schema/api/hashSet.ts

@@ -1,25 +1,12 @@
+import type { KeyError } from "@fncts/schema/ParseError";
 import type { Sized } from "@fncts/test/control/Sized";
 
-import {
-  type ArrayNode,
-  type CollisionNode,
-  type EmptyNode,
-  HashSetTypeId,
-  HashSetVariance,
-  type IndexedNode,
-  type LeafNode,
-  type Node,
-} from "@fncts/base/collection/immutable/HashSet/definition";
 import { ASTAnnotation } from "@fncts/schema/ASTAnnotation";
-import { ASTAnnotationMap } from "@fncts/schema/ASTAnnotationMap";
 
 export function hashSet<A>(value: Schema<A>): Schema<HashSet<A>> {
-  return Schema.declaration(
-    Vector(value),
-    inline(value),
-    hashSetParser,
-    ASTAnnotationMap.empty.annotate(ASTAnnotation.Identifier, "HashMap").annotate(ASTAnnotation.GenHook, gen),
-  );
+  return Schema.declaration(Vector(value), hashSetParser(true), hashSetParser(false))
+    .annotate(ASTAnnotation.Identifier, `HashSet<${value.show()}>`)
+    .annotate(ASTAnnotation.GenHook, gen);
 }
 
 /**
@@ -58,108 +45,35 @@ export function deriveHashSet<A extends HashSet<any>>(
   return unsafeCoerce(hashSetFromArray(value));
 }
 
-function hashSetParser<A>(value: Schema<A>): Parser<HashSet<A>> {
-  const schema = hashSet(value);
-  return Parser.make((u, options) => {
-    if (!HashSet.is(u)) {
-      return ParseResult.fail(ParseError.TypeError(schema.ast, u));
-    }
-    const allErrors = options?.allErrors;
-    const errors    = Vector.emptyPushable<ParseError>();
-    const out       = HashSet.empty<A>().beginMutation;
-    for (const v of u) {
-      const tv = value.decode(v, options);
-      Either.concrete(tv);
-      if (tv.isLeft()) {
-        errors.push(ParseError.TypeError(value.ast, tv.left));
-        if (!allErrors) {
-          return ParseResult.failures(errors);
-        }
-        continue;
+function hashSetParser(isDecoding: boolean) {
+  return <A>(value: Schema<A>): Parser<HashSet<unknown>> => {
+    const schema     = hashSet(value);
+    const parseValue = isDecoding ? value.decode : value.encode;
+    return Parser.make((u, options) => {
+      if (!HashSet.is(u)) {
+        return ParseResult.fail(ParseError.TypeError(schema.ast, u));
       }
-      out.add(tv.right);
-    }
-    return errors.isNonEmpty() ? ParseResult.failures(errors) : ParseResult.succeed(out.endMutation);
-  });
-}
 
-function emptyNodeSchema<A>(_value: Schema<A>): Schema<EmptyNode<A>> {
-  return Schema.struct({
-    _tag: Schema.literal("EmptyNode"),
-    modify: Schema.any,
-  });
-}
-
-function leafNodeSchema<A>(value: Schema<A>): Schema<LeafNode<A>> {
-  return Schema.struct({
-    _tag: Schema.literal("LeafNode"),
-    edit: Schema.number,
-    hash: Schema.number,
-    value: value,
-    modify: Schema.any,
-  });
-}
-
-function collisionNodeSchema<A>(value: Schema<A>): Schema<CollisionNode<A>> {
-  return Schema.lazy(() =>
-    Schema.struct({
-      _tag: Schema.literal("CollisionNode"),
-      edit: Schema.number,
-      hash: Schema.number,
-      children: nodeSchema(value).mutableArray,
-      modify: Schema.any,
-    }),
-  );
-}
-
-function indexedNodeSchema<A>(value: Schema<A>): Schema<IndexedNode<A>> {
-  return Schema.lazy(() =>
-    Schema.struct({
-      _tag: Schema.literal("IndexedNode"),
-      edit: Schema.number,
-      mask: Schema.number,
-      children: nodeSchema(value).mutableArray,
-      modify: Schema.any,
-    }),
-  );
-}
-
-function arrayNodeSchema<A>(value: Schema<A>): Schema<ArrayNode<A>> {
-  return Schema.lazy(() =>
-    Schema.struct({
-      _tag: Schema.literal("ArrayNode"),
-      edit: Schema.number,
-      size: Schema.number,
-      children: nodeSchema(value).mutableArray,
-      modify: Schema.any,
-    }),
-  );
-}
-
-function nodeSchema<A>(value: Schema<A>): Schema<Node<A>> {
-  return Schema.union(
-    emptyNodeSchema(value),
-    leafNodeSchema(value),
-    collisionNodeSchema(value),
-    indexedNodeSchema(value),
-    arrayNodeSchema(value),
-  );
-}
-
-function inline<A>(value: Schema<A>): Schema<HashSet<A>> {
-  return Schema.struct({
-    [HashSetTypeId]: Schema.uniqueSymbol(HashSetTypeId),
-    [HashSetVariance]: Schema.any,
-    _editable: Schema.boolean,
-    _edit: Schema.number,
-    config: Schema.any,
-    _root: nodeSchema(value),
-    _size: Schema.number,
-    size: Schema.number,
-    [Symbol.iterator]: Schema.any,
-    [Symbol.hash]: Schema.any,
-    [Symbol.equals]: Schema.any,
-  });
+      const allErrors = options?.allErrors;
+      const errors    = Vector.emptyPushable<KeyError>();
+      const out       = HashSet.empty<unknown>().beginMutation;
+      for (const v of u) {
+        const tv = parseValue(v, options);
+        Either.concrete(tv);
+        if (tv.isLeft()) {
+          errors.push(ParseError.KeyError(value.ast, value, tv.left));
+          if (!allErrors) {
+            return ParseResult.fail(ParseError.IterableError(schema.ast, u, errors));
+          }
+          continue;
+        }
+        out.add(tv.right);
+      }
+      return errors.isNonEmpty()
+        ? ParseResult.fail(ParseError.IterableError(schema.ast, u, errors))
+        : ParseResult.succeed(out.endMutation);
+    });
+  };
 }
 
 function gen<A>(value: Gen<Sized, A>): Gen<Sized, HashSet<A>> {

package/_src/Schema/api/immutableArray.ts

@@ -1,10 +1,6 @@
 import type { Sized } from "@fncts/test/control/Sized";
 
-import {
-  ImmutableArray,
-  ImmutableArrayTypeId,
-  ImmutableArrayVariance,
-} from "@fncts/base/collection/immutable/ImmutableArray";
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
 
 /**
@@ -12,12 +8,9 @@ import { Vector } from "@fncts/base/collection/immutable/Vector";
  * @tsplus static fncts.schema.SchemaOps immutableArray
  */
 export function immutableArray<A>(value: Schema<A>): Schema<ImmutableArray<A>> {
-  return Schema.declaration(
-    Vector(value),
-    inline(value),
-    parser,
-    ASTAnnotationMap.empty.annotate(ASTAnnotation.Identifier, "ImmutableArray").annotate(ASTAnnotation.GenHook, gen),
-  );
+  return Schema.declaration(Vector(value), parser(true), parser(false))
+    .annotate(ASTAnnotation.Identifier, `ImmutableArray<${value.show()}>`)
+    .annotate(ASTAnnotation.GenHook, gen);
 }
 
 /**
@@ -45,42 +38,19 @@ export function deriveImmutableArray<A extends ImmutableArray<any>>(
   return unsafeCoerce(immutableArrayFromArray(value));
 }
 
-function parser<A>(value: Schema<A>): Parser<ImmutableArray<A>> {
-  const schema = immutableArray(value);
-  return Parser.make((u, options) => {
-    if (!ImmutableArray.is(u)) {
-      return ParseResult.fail(ParseError.TypeError(schema.ast, u));
-    }
-    const out: Array<A> = [];
-    const errors        = Vector.emptyPushable<ParseError>();
-    const allErrors     = options?.allErrors;
-    const index         = 0;
-    for (const v of u) {
-      const t = value.decode(v, options);
-      Either.concrete(t);
-      if (t.isLeft()) {
-        errors.push(ParseError.IndexError(index, t.left.errors));
-        if (allErrors) {
-          continue;
-        }
-        return ParseResult.failures(errors);
-      } else {
-        out.push(t.right);
+function parser(isDecoding: boolean) {
+  return <A>(value: Schema<A>): Parser<ImmutableArray<unknown>> => {
+    const schema      = immutableArray(value);
+    const arraySchema = value.array;
+    const parse       = isDecoding ? arraySchema.decode : arraySchema.encode;
+    return Parser.make((u, options) => {
+      if (!ImmutableArray.is(u)) {
+        return ParseResult.fail(ParseError.TypeError(schema.ast, u));
       }
-    }
-    return errors.isNonEmpty() ? ParseResult.failures(errors) : ParseResult.succeed(new ImmutableArray(out));
-  });
-}
 
-function inline<A>(value: Schema<A>): Schema<ImmutableArray<A>> {
-  return Schema.struct({
-    [ImmutableArrayTypeId]: Schema.uniqueSymbol(ImmutableArrayTypeId),
-    [ImmutableArrayVariance]: Schema.any,
-    _array: Schema.array(value),
-    [Symbol.equals]: Schema.any,
-    [Symbol.hash]: Schema.any,
-    [Symbol.iterator]: Schema.any,
-  });
+      return parse(u, options).map((out) => new ImmutableArray(out as Array<unknown>));
+    });
+  };
 }
 
 function gen<A>(value: Gen<Sized, A>): Gen<Sized, ImmutableArray<A>> {

package/_src/Schema/api/list.ts

@@ -1,18 +1,14 @@
+import type { IndexError } from "@fncts/schema/ParseError";
 import type { Sized } from "@fncts/test/control/Sized";
 
-import { ListTypeId } from "@fncts/base/collection/immutable/List";
-
 /**
  * @tsplus static fncts.schema.SchemaOps list
  * @tsplus getter fncts.Schema.Schema list
  */
 export function list<A>(value: Schema<A>): Schema<List<A>> {
-  return Schema.declaration(
-    Vector(value),
-    inline(value),
-    parser,
-    ASTAnnotationMap.empty.annotate(ASTAnnotation.Identifier, "List").annotate(ASTAnnotation.GenHook, gen),
-  );
+  return Schema.declaration(Vector(value), parser(true), parser(false))
+    .annotate(ASTAnnotation.Identifier, `List<${value.show()}>`)
+    .annotate(ASTAnnotation.GenHook, gen);
 }
 
 /**
@@ -40,55 +36,36 @@ export function deriveList<A extends List<any>>(
   return unsafeCoerce(listFromArray(value));
 }
 
-function parser<A>(value: Schema<A>): Parser<List<A>> {
-  const schema = list(value);
-  return Parser.make((u, options) => {
-    if (!List.is(u)) {
-      return ParseResult.fail(ParseError.TypeError(schema.ast, u));
-    }
-    const out       = new ListBuffer<A>();
-    const errors    = Vector.emptyPushable<ParseError>();
-    const allErrors = options?.allErrors;
-    const index     = 0;
-    for (const v of u) {
-      const t = value.decode(v, options);
-      Either.concrete(t);
-      if (t.isLeft()) {
-        errors.push(ParseError.IndexError(index, t.left.errors));
-        if (allErrors) {
-          continue;
+function parser(isDecoding: boolean) {
+  return <A>(value: Schema<A>): Parser<List<unknown>> => {
+    const schema     = list(value);
+    const parseValue = isDecoding ? value.decode : value.encode;
+    return Parser.make((u, options) => {
+      if (!List.is(u)) {
+        return ParseResult.fail(ParseError.TypeError(schema.ast, u));
+      }
+      const out       = new ListBuffer<unknown>();
+      const errors    = Vector.emptyPushable<IndexError>();
+      const allErrors = options?.allErrors;
+      const index     = 0;
+      for (const v of u) {
+        const t = parseValue(v, options);
+        Either.concrete(t);
+        if (t.isLeft()) {
+          errors.push(ParseError.IndexError(index, t.left));
+          if (allErrors) {
+            continue;
+          }
+          return ParseResult.fail(ParseError.IterableError(schema.ast, u, errors));
+        } else {
+          out.append(t.right);
         }
-        return ParseResult.failures(errors);
-      } else {
-        out.append(t.right);
       }
-    }
-    return errors.isNonEmpty() ? ParseResult.failures(errors) : ParseResult.succeed(out.toList);
-  });
-}
-
-function nil<A>(_value: Schema<A>): Schema<Nil<A>> {
-  return Schema.struct({
-    _tag: Schema.literal("Nil"),
-    [ListTypeId]: Schema.uniqueSymbol(ListTypeId),
-    [Symbol.iterator]: Schema.any,
-  });
-}
-
-function cons<A>(value: Schema<A>): Schema<Cons<A>> {
-  return Schema.lazy(() =>
-    Schema.struct({
-      _tag: Schema.literal("Cons"),
-      [ListTypeId]: Schema.uniqueSymbol(ListTypeId),
-      [Symbol.iterator]: Schema.any,
-      head: value,
-      tail: inline(value),
-    }),
-  );
-}
-
-function inline<A>(value: Schema<A>): Schema<List<A>> {
-  return Schema.lazy(() => Schema.union(nil(value), cons(value)));
+      return errors.isNonEmpty()
+        ? ParseResult.fail(ParseError.IterableError(schema.ast, u, errors))
+        : ParseResult.succeed(out.toList);
+    });
+  };
 }
 
 function gen<A>(value: Gen<Sized, A>): Gen<Sized, List<A>> {

package/_src/Schema/api/map.ts

@@ -0,0 +1,93 @@
+import type { KeyError } from "@fncts/schema/ParseError";
+import type { Sized } from "@fncts/test/control/Sized";
+
+/**
+ * @tsplus static fncts.schema.SchemaOps map
+ */
+export function map<K, V>(key: Schema<K>, value: Schema<V>): Schema<Map<K, V>> {
+  return Schema.declaration(Vector(key, value), mapParser(true), mapParser(false))
+    .annotate(ASTAnnotation.Identifier, `Map<${key.show()}, ${value.show()}>`)
+    .annotate(ASTAnnotation.GenHook, gen);
+}
+
+/**
+ * @tsplus static fncts.schema.SchemaOps mapFromRecord
+ */
+export function mapFromRecord<K extends string | symbol, V>(key: Schema<K>, value: Schema<V>): Schema<Map<K, V>> {
+  return Schema.record(key, value).transform(
+    map(key, value),
+    (input) => {
+      const out = new Map<K, V>();
+      for (const [k, v] of Object.entries(input)) {
+        out.set(k as K, v as V);
+      }
+      return out;
+    },
+    (input) => {
+      const out = {} as Record<K, V>;
+      input.forEach((v, k) => {
+        out[k] = v;
+      });
+      return out;
+    },
+  );
+}
+
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.Map]<_> 10
+ */
+export function deriveMap<A extends Map<any, any>>(
+  // @ts-expect-error
+  ...[key, value]: [A] extends [Map<infer K, infer V>]
+    ? Check<Check.IsEqual<A, Map<K, V>> & Check.Extends<K, string | symbol>> extends Check.True
+      ? [key: Schema<K>, value: Schema<V>]
+      : never
+    : never
+): Schema<A> {
+  return unsafeCoerce(mapFromRecord(key as Schema<string | symbol>, value));
+}
+
+function mapParser(isDecoding: boolean) {
+  return <K, V>(key: Schema<K>, value: Schema<V>): Parser<Map<unknown, unknown>> => {
+    const schema = map(key, value);
+    return Parser.make((u, options) => {
+      if (!(u instanceof Map)) {
+        return ParseResult.fail(ParseError.TypeError(schema.ast, u));
+      }
+      const allErrors   = options?.allErrors;
+      const errors      = Vector.emptyPushable<KeyError>();
+      const out         = new Map();
+      const keyParser   = isDecoding ? key.decode : key.encode;
+      const valueParser = isDecoding ? value.decode : value.encode;
+      for (const [k, v] of u) {
+        const tk = keyParser(k, options);
+        Either.concrete(tk);
+        if (tk.isLeft()) {
+          errors.push(ParseError.KeyError(key.ast, k, tk.left));
+          if (!allErrors) {
+            return ParseResult.fail(ParseError.IterableError(schema.ast, u, errors));
+          }
+        }
+        const tv = valueParser(v, options);
+        Either.concrete(tv);
+        if (tv.isLeft()) {
+          errors.push(ParseError.KeyError(key.ast, k, ParseError.TypeError(value.ast, tv.left)));
+          if (!allErrors) {
+            return ParseResult.fail(ParseError.IterableError(schema.ast, u, errors));
+          }
+        }
+        if (tk.isLeft() || tv.isLeft()) {
+          continue;
+        }
+        out.set(tk.right, tv.right);
+      }
+      return errors.isNonEmpty()
+        ? ParseResult.fail(ParseError.IterableError(schema.ast, u, errors))
+        : ParseResult.succeed(out);
+    });
+  };
+}
+
+function gen<K, V>(key: Gen<Sized, K>, value: Gen<Sized, V>): Gen<Sized, Map<K, V>> {
+  return Gen.array(Gen.tuple(key, value)).map((pairs) => new Map(pairs));
+}