mapFromEntries codec added

docs/modules/NonEmptyString.ts.md

@@ -1,6 +1,6 @@
 ---
 title: NonEmptyString.ts
-nav_order: 19
+nav_order: 20
 parent: Modules
 ---
 

docs/modules/NumberFromString.ts.md

@@ -1,6 +1,6 @@
 ---
 title: NumberFromString.ts
-nav_order: 20
+nav_order: 21
 parent: Modules
 ---
 

docs/modules/UUID.ts.md

@@ -1,6 +1,6 @@
 ---
 title: UUID.ts
-nav_order: 27
+nav_order: 29
 parent: Modules
 ---
 

docs/modules/mapFromEntries.ts.md

@@ -0,0 +1,44 @@
+---
+title: mapFromEntries.ts
+nav_order: 17
+parent: Modules
+---
+
+# mapFromEntries overview
+
+Added in v0.5.18
+
+---
+
+<h2 class="text-delta">Table of contents</h2>
+
+- [MapFromEntriesC (interface)](#mapfromentriesc-interface)
+- [mapFromEntries](#mapfromentries)
+
+---
+
+# MapFromEntriesC (interface)
+
+**Signature**
+
+```ts
+export interface MapFromEntriesC<K extends t.Mixed, V extends t.Mixed>
+  extends t.Type<Map<t.TypeOf<K>, t.TypeOf<V>>, Array<[t.OutputOf<K>, t.OutputOf<V>]>, unknown> {}
+```
+
+Added in v0.5.18
+
+# mapFromEntries
+
+**Signature**
+
+```ts
+export function mapFromEntries<K extends t.Mixed, V extends t.Mixed>(
+  keyCodec: K,
+  KO: Ord<t.TypeOf<K>>,
+  valueCodec: V,
+  name: string = `Map<${keyCodec.name}, ${valueCodec.name}>`
+): MapFromEntriesC<K, V> { ... }
+```
+
+Added in v0.5.18

docs/modules/mapOutput.ts.md

@@ -1,6 +1,6 @@
 ---
 title: mapOutput.ts
-nav_order: 17
+nav_order: 18
 parent: Modules
 ---
 

docs/modules/nonEmptyArray.ts.md

@@ -1,6 +1,6 @@
 ---
 title: nonEmptyArray.ts
-nav_order: 18
+nav_order: 19
 parent: Modules
 ---
 

docs/modules/option.ts.md

@@ -1,6 +1,6 @@
 ---
 title: option.ts
-nav_order: 21
+nav_order: 22
 parent: Modules
 ---
 

docs/modules/optionFromNullable.ts.md

@@ -1,6 +1,6 @@
 ---
 title: optionFromNullable.ts
-nav_order: 22
+nav_order: 23
 parent: Modules
 ---
 

docs/modules/readonlyMapFromEntries.ts.md

@@ -0,0 +1,44 @@
+---
+title: readonlyMapFromEntries.ts
+nav_order: 24
+parent: Modules
+---
+
+# readonlyMapFromEntries overview
+
+Added in v0.5.18
+
+---
+
+<h2 class="text-delta">Table of contents</h2>
+
+- [ReadonlyMapFromEntriesC (interface)](#readonlymapfromentriesc-interface)
+- [readonlyMapFromEntries](#readonlymapfromentries)
+
+---
+
+# ReadonlyMapFromEntriesC (interface)
+
+**Signature**
+
+```ts
+export interface ReadonlyMapFromEntriesC<K extends t.Mixed, V extends t.Mixed>
+  extends t.Type<ReadonlyMap<t.TypeOf<K>, t.TypeOf<V>>, ReadonlyArray<[t.OutputOf<K>, t.OutputOf<V>]>, unknown> {}
+```
+
+Added in v0.5.18
+
+# readonlyMapFromEntries
+
+**Signature**
+
+```ts
+export function readonlyMapFromEntries<K extends t.Mixed, V extends t.Mixed>(
+  keyCodec: K,
+  KO: Ord<t.TypeOf<K>>,
+  valueCodec: V,
+  name: string = `ReadonlyMap<${keyCodec.name}, ${valueCodec.name}>`
+): ReadonlyMapFromEntriesC<K, V> { ... }
+```
+
+Added in v0.5.18

docs/modules/readonlyNonEmptyArray.ts.md

@@ -1,6 +1,6 @@
 ---
 title: readonlyNonEmptyArray.ts
-nav_order: 23
+nav_order: 25
 parent: Modules
 ---
 

docs/modules/readonlySetFromArray.ts.md

@@ -1,6 +1,6 @@
 ---
 title: readonlySetFromArray.ts
-nav_order: 24
+nav_order: 26
 parent: Modules
 ---
 

docs/modules/regexp.ts.md

@@ -1,6 +1,6 @@
 ---
 title: regexp.ts
-nav_order: 25
+nav_order: 27
 parent: Modules
 ---
 

docs/modules/setFromArray.ts.md

@@ -1,6 +1,6 @@
 ---
 title: setFromArray.ts
-nav_order: 26
+nav_order: 28
 parent: Modules
 ---
 

docs/modules/withEncode.ts.md

@@ -1,6 +1,6 @@
 ---
 title: withEncode.ts
-nav_order: 28
+nav_order: 30
 parent: Modules
 ---
 

docs/modules/withFallback.ts.md

@@ -1,6 +1,6 @@
 ---
 title: withFallback.ts
-nav_order: 29
+nav_order: 31
 parent: Modules
 ---
 

docs/modules/withMessage.ts.md

@@ -1,6 +1,6 @@
 ---
 title: withMessage.ts
-nav_order: 30
+nav_order: 32
 parent: Modules
 ---
 

docs/modules/withValidate.ts.md

@@ -1,6 +1,6 @@
 ---
 title: withValidate.ts
-nav_order: 31
+nav_order: 33
 parent: Modules
 ---
 

src/index.ts

@@ -147,3 +147,13 @@ export * from './withEncode'
  * @since 0.5.13
  */
 export * from './BooleanFromNumber'
+
+/**
+ * @since 0.5.18
+ */
+export * from './mapFromEntries'
+
+/**
+ * @since 0.5.18
+ */
+export * from './readonlyMapFromEntries'

src/mapFromEntries.ts

@@ -0,0 +1,60 @@
+/**
+ * @since 0.5.18
+ */
+import * as A from 'fp-ts/lib/Array'
+import { chain } from 'fp-ts/lib/Either'
+import { fromFoldable, toArray } from 'fp-ts/lib/Map'
+import { Ord } from 'fp-ts/Ord'
+import { getLastSemigroup } from 'fp-ts/lib/Semigroup'
+import { pipe, Predicate } from 'fp-ts/function'
+import * as t from 'io-ts'
+
+interface Next<A> {
+  readonly done?: boolean
+  readonly value: A
+}
+
+const every = <K, V>(pk: Predicate<K>, pv: Predicate<V>) => (ma: Map<K, V>): boolean => {
+  const entries = ma.entries()
+  let e: Next<[K, V]>
+  while (!(e = entries.next()).done) {
+    if (pk(e.value[0]) === false || pv(e.value[1]) === false) {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * @since 0.5.18
+ */
+export interface MapFromEntriesC<K extends t.Mixed, V extends t.Mixed>
+  extends t.Type<Map<t.TypeOf<K>, t.TypeOf<V>>, Array<[t.OutputOf<K>, t.OutputOf<V>]>, unknown> {}
+
+/**
+ * @since 0.5.18
+ */
+export function mapFromEntries<K extends t.Mixed, V extends t.Mixed>(
+  keyCodec: K,
+  KO: Ord<t.TypeOf<K>>,
+  valueCodec: V,
+  name: string = `Map<${keyCodec.name}, ${valueCodec.name}>`
+): MapFromEntriesC<K, V> {
+  const arr = t.array(t.tuple([keyCodec, valueCodec]))
+  const toArrayO = toArray(KO)
+  const fromArrayO = fromFoldable(KO, getLastSemigroup<t.TypeOf<V>>(), A.Foldable)
+  const everyO = every(keyCodec.is, valueCodec.is)
+  return new t.Type(
+    name,
+    (u): u is Map<t.TypeOf<K>, t.TypeOf<V>> => u instanceof Map && everyO(u),
+    (u, c) =>
+      pipe(
+        arr.validate(u, c),
+        chain(as => {
+          const map = fromArrayO(as)
+          return map.size !== as.length ? t.failure(u, c) : t.success(map)
+        })
+      ),
+    a => arr.encode(toArrayO(a))
+  )
+}

src/readonlyMapFromEntries.ts

@@ -0,0 +1,24 @@
+/**
+ * @since 0.5.18
+ */
+import { Ord } from 'fp-ts/lib/Ord'
+import * as t from 'io-ts'
+import { mapFromEntries } from './mapFromEntries'
+
+/**
+ * @since 0.5.18
+ */
+export interface ReadonlyMapFromEntriesC<K extends t.Mixed, V extends t.Mixed>
+  extends t.Type<ReadonlyMap<t.TypeOf<K>, t.TypeOf<V>>, ReadonlyArray<[t.OutputOf<K>, t.OutputOf<V>]>, unknown> {}
+
+/**
+ * @since 0.5.18
+ */
+export function readonlyMapFromEntries<K extends t.Mixed, V extends t.Mixed>(
+  keyCodec: K,
+  KO: Ord<t.TypeOf<K>>,
+  valueCodec: V,
+  name: string = `ReadonlyMap<${keyCodec.name}, ${valueCodec.name}>`
+): ReadonlyMapFromEntriesC<K, V> {
+  return mapFromEntries(keyCodec, KO, valueCodec, name) as any
+}

test/mapFromEntries.ts

@@ -0,0 +1,55 @@
+import * as assert from 'assert'
+import { pipe } from 'fp-ts/function'
+import { Ord, ordString, contramap } from 'fp-ts/Ord'
+import * as t from 'io-ts'
+import { assertSuccess, assertFailure } from './helpers'
+
+import { mapFromEntries } from '../src/mapFromEntries'
+
+describe('mapFromEntries', () => {
+  const K = t.type({ a: t.string })
+  const KO: Ord<t.TypeOf<typeof K>> = pipe(
+    ordString,
+    contramap(m => m.a)
+  )
+  const C = t.type({ b: t.number })
+  const T = mapFromEntries(K, KO, C)
+
+  it('name', () => {
+    const T = mapFromEntries(K, KO, C, 'T')
+    assert.strictEqual(T.name, 'T')
+  })
+
+  it('is', () => {
+    assert.strictEqual(T.is(new Map()), true)
+    assert.strictEqual(T.is(new Map([[{ a: 'a' }, { b: 1 }]])), true)
+    assert.strictEqual(T.is(null), false)
+    assert.strictEqual(T.is(undefined), false)
+    assert.strictEqual(T.is({}), false)
+    assert.strictEqual(T.is([]), false)
+    assert.strictEqual(T.is(new Map([['a', 'b']])), false)
+    assert.strictEqual(T.is(new Map([['a', { b: 1 }]])), false)
+    assert.strictEqual(T.is(new Map([[{ a: 'a' }, 1]])), false)
+  })
+
+  it('decode', () => {
+    assertSuccess(T.decode([]), new Map())
+    assertSuccess(
+      T.decode([[{ a: '1' }, { b: 1 }], [{ a: '2' }, { b: 2 }]]),
+      new Map([[{ a: '1' }, { b: 1 }], [{ a: '2' }, { b: 2 }]])
+    )
+    assertFailure(
+      T,
+      [[{ a: '1' }, { b: 1 }], [{ a: '1' }, { b: 2 }]],
+      ['Invalid value [[{"a":"1"},{"b":1}],[{"a":"1"},{"b":2}]] supplied to : Map<{ a: string }, { b: number }>']
+    )
+  })
+
+  it('encode', () => {
+    assert.deepStrictEqual(T.encode(new Map()), [])
+    assert.deepStrictEqual(T.encode(new Map([[{ a: '1' }, { b: 1 }], [{ a: '2' }, { b: 2 }]])), [
+      [{ a: '1' }, { b: 1 }],
+      [{ a: '2' }, { b: 2 }]
+    ])
+  })
+})