Schemable: add readonly combinator, closes #525

gcanti · gcanti · commit 2dc13a8204df · 2021-02-22T16:34:34.000+01:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -14,6 +14,14 @@
 **Note**: Gaps between patch versions are faulty/broken releases.
 **Note**: A feature tagged as Experimental is in a high state of flux, you're at risk of it changing without notice.
 
+# 2.2.15
+
+- **Experimental**
+  - `Schemable`
+    - (\*) add `readonly` combinator (@gcanti)
+
+(\*) breaking change
+
 # 2.2.14
 
 - **Experimental**
diff --git a/docs/modules/Decoder.ts.md b/docs/modules/Decoder.ts.md
@@ -46,6 +46,7 @@ Added in v2.2.7
   - [nullable](#nullable)
   - [parse](#parse)
   - [partial](#partial)
+  - [readonly](#readonly)
   - [record](#record)
   - [refine](#refine)
   - [sum](#sum)
@@ -328,6 +329,16 @@ export declare const partial: <A>(
 
 Added in v2.2.7
 
+## readonly
+
+**Signature**
+
+```ts
+export declare const readonly: <I, A>(decoder: Decoder<I, A>) => Decoder<I, Readonly<A>>
+```
+
+Added in v2.2.15
+
 ## record
 
 **Signature**
diff --git a/docs/modules/Eq.ts.md b/docs/modules/Eq.ts.md
@@ -25,6 +25,7 @@ Added in v2.2.2
   - [lazy](#lazy)
   - [nullable](#nullable)
   - [partial](#partial)
+  - [readonly](#readonly)
   - [record](#record)
   - [sum](#sum)
   - [tuple](#tuple)
@@ -97,6 +98,16 @@ export declare function partial<A>(properties: { [K in keyof A]: Eq<A[K]> }): Eq
 
 Added in v2.2.2
 
+## readonly
+
+**Signature**
+
+```ts
+export declare const readonly: <A>(eq: E.Eq<A>) => E.Eq<Readonly<A>>
+```
+
+Added in v2.2.15
+
 ## record
 
 **Signature**
diff --git a/docs/modules/Guard.ts.md b/docs/modules/Guard.ts.md
@@ -28,6 +28,7 @@ Added in v2.2.0
   - [lazy](#lazy)
   - [nullable](#nullable)
   - [partial](#partial)
+  - [readonly](#readonly)
   - [record](#record)
   - [refine](#refine)
   - [sum](#sum)
@@ -142,6 +143,16 @@ export declare const partial: <A>(
 
 Added in v2.2.0
 
+## readonly
+
+**Signature**
+
+```ts
+export declare const readonly: <I, A extends I>(guard: Guard<I, A>) => Guard<I, Readonly<A>>
+```
+
+Added in v2.2.15
+
 ## record
 
 **Signature**
diff --git a/docs/modules/Schemable.ts.md b/docs/modules/Schemable.ts.md
@@ -71,6 +71,7 @@ export interface Schemable<S> {
     tag: T
   ) => <A>(members: { [K in keyof A]: HKT<S, A[K] & Record<T, K>> }) => HKT<S, A[keyof A]>
   readonly lazy: <A>(id: string, f: () => HKT<S, A>) => HKT<S, A>
+  readonly readonly: <A>(sa: HKT<S, A>) => HKT<S, Readonly<A>>
 }
 ```
 
@@ -98,6 +99,7 @@ export interface Schemable1<S extends URIS> {
     tag: T
   ) => <A>(members: { [K in keyof A]: Kind<S, A[K] & Record<T, K>> }) => Kind<S, A[keyof A]>
   readonly lazy: <A>(id: string, f: () => Kind<S, A>) => Kind<S, A>
+  readonly readonly: <A>(sa: Kind<S, A>) => Kind<S, Readonly<A>>
 }
 ```
 
@@ -129,6 +131,7 @@ export interface Schemable2C<S extends URIS2, E> {
     tag: T
   ) => <A>(members: { [K in keyof A]: Kind2<S, E, A[K] & Record<T, K>> }) => Kind2<S, E, A[keyof A]>
   readonly lazy: <A>(id: string, f: () => Kind2<S, E, A>) => Kind2<S, E, A>
+  readonly readonly: <A>(sa: Kind2<S, E, A>) => Kind2<S, E, Readonly<A>>
 }
 ```
 
diff --git a/docs/modules/TaskDecoder.ts.md b/docs/modules/TaskDecoder.ts.md
@@ -46,6 +46,7 @@ Added in v2.2.7
   - [nullable](#nullable)
   - [parse](#parse)
   - [partial](#partial)
+  - [readonly](#readonly)
   - [record](#record)
   - [refine](#refine)
   - [sum](#sum)
@@ -331,6 +332,16 @@ export declare const partial: <A>(
 
 Added in v2.2.7
 
+## readonly
+
+**Signature**
+
+```ts
+export declare const readonly: <I, A>(decoder: TaskDecoder<I, A>) => TaskDecoder<I, Readonly<A>>
+```
+
+Added in v2.2.15
+
 ## record
 
 **Signature**
diff --git a/docs/modules/Type.ts.md b/docs/modules/Type.ts.md
@@ -25,6 +25,7 @@ Added in v2.2.3
   - [lazy](#lazy)
   - [nullable](#nullable)
   - [partial](#partial)
+  - [readonly](#readonly)
   - [record](#record)
   - [refine](#refine)
   - [sum](#sum)
@@ -103,6 +104,16 @@ export declare const partial: <A>(properties: { [K in keyof A]: Type<A[K]> }) =>
 
 Added in v2.2.3
 
+## readonly
+
+**Signature**
+
+```ts
+export declare const readonly: <A>(type: Type<A>) => Type<Readonly<A>>
+```
+
+Added in v2.2.15
+
 ## record
 
 **Signature**
diff --git a/dtslint/ts3.5/Decoder.ts b/dtslint/ts3.5/Decoder.ts
@@ -147,3 +147,14 @@ pipe(
   _.number,
   _.mapLeftWithInput((u) => FS.of(DE.leaf(u, 'not a number')))
 )
+
+//
+// readonly
+//
+
+// $ExpectType Decoder<unknown, Readonly<{ a: string; }>>
+_.readonly(
+  _.type({
+    a: _.string
+  })
+)
diff --git a/dtslint/ts3.5/Eq.ts b/dtslint/ts3.5/Eq.ts
@@ -27,3 +27,14 @@ const S2 = _.type({ _tag: _.Schemable.literal('B'), b: _.number })
 _.sum('_tag')({ A: S1, B: S2 })
 // // $ExpectError
 // _.sum('_tag')({ A: S1, B: S1 })
+
+//
+// readonly
+//
+
+// $ExpectType Eq<Readonly<{ a: string; }>>
+_.readonly(
+  _.type({
+    a: _.string
+  })
+)
diff --git a/dtslint/ts3.5/Guard.ts b/dtslint/ts3.5/Guard.ts
@@ -42,3 +42,14 @@ const S2 = _.type({ _tag: _.literal('B'), b: _.number })
 _.sum('_tag')({ A: S1, B: S2 })
 // $ExpectError
 _.sum('_tag')({ A: S1, B: S1 })
+
+//
+// readonly
+//
+
+// $ExpectType Guard<unknown, Readonly<{ a: string; }>>
+_.readonly(
+  _.type({
+    a: _.string
+  })
+)
diff --git a/dtslint/ts3.5/Schema.ts b/dtslint/ts3.5/Schema.ts
@@ -172,3 +172,10 @@ make((S) =>
 make((S) => S.union())
 make((S) => S.union(S.string)) // $ExpectType Schema<string>
 make((S) => S.union(S.string, S.number)) // $ExpectType Schema<string | number>
+
+//
+// readonly
+//
+
+// $ExpectType Schema<Readonly<{ a: string; }>>
+make((S) => S.readonly(S.type({ a: S.string })))
diff --git a/dtslint/ts3.5/TaskDecoder.ts b/dtslint/ts3.5/TaskDecoder.ts
@@ -11,3 +11,14 @@ const S2 = _.type({ _tag: _.literal('B'), b: _.number })
 _.sum('_tag')({ A: S1, B: S2 })
 // $ExpectError
 _.sum('_tag')({ A: S1, B: S1 })
+
+//
+// readonly
+//
+
+// $ExpectType TaskDecoder<unknown, Readonly<{ a: string; }>>
+_.readonly(
+  _.type({
+    a: _.string
+  })
+)
diff --git a/dtslint/ts3.5/Type.ts b/dtslint/ts3.5/Type.ts
@@ -15,3 +15,14 @@ _.partial({
     c: _.number
   })
 })
+
+//
+// readonly
+//
+
+// $ExpectType Type<Readonly<{ a: string; }>>
+_.readonly(
+  _.type({
+    a: _.string
+  })
+)
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "io-ts",
-  "version": "2.2.14",
+  "version": "2.2.15",
   "description": "TypeScript runtime type system for IO decoding/encoding",
   "main": "lib/index.js",
   "module": "es6/index.js",
diff --git a/src/Decoder.ts b/src/Decoder.ts
@@ -12,7 +12,7 @@ import { Alt2, Alt2C } from 'fp-ts/lib/Alt'
 import { Bifunctor2 } from 'fp-ts/lib/Bifunctor'
 import { Category2 } from 'fp-ts/lib/Category'
 import * as E from 'fp-ts/lib/Either'
-import { Refinement } from 'fp-ts/lib/function'
+import { identity, Refinement } from 'fp-ts/lib/function'
 import { Functor2 } from 'fp-ts/lib/Functor'
 import { MonadThrow2C } from 'fp-ts/lib/MonadThrow'
 import { pipe } from 'fp-ts/lib/pipeable'
@@ -356,6 +356,12 @@ export const lazy: <I, A>(id: string, f: () => Decoder<I, A>) => Decoder<I, A> =
   /*#__PURE__*/
   K.lazy(M)((id, e) => FS.of(DE.lazy(id, e)))
 
+/**
+ * @category combinators
+ * @since 2.2.15
+ */
+export const readonly: <I, A>(decoder: Decoder<I, A>) => Decoder<I, Readonly<A>> = identity
+
 // -------------------------------------------------------------------------------------
 // non-pipeables
 // -------------------------------------------------------------------------------------
@@ -471,7 +477,8 @@ export const Schemable: S.Schemable2C<URI, unknown> = {
   tuple: tuple as S.Schemable2C<URI, unknown>['tuple'],
   intersect,
   sum,
-  lazy
+  lazy,
+  readonly
 }
 
 /**
diff --git a/src/Eq.ts b/src/Eq.ts
@@ -10,6 +10,7 @@
  */
 import * as A from 'fp-ts/lib/Array'
 import * as E from 'fp-ts/lib/Eq'
+import { identity } from 'fp-ts/lib/function'
 import * as R from 'fp-ts/lib/Record'
 import { memoize, Schemable1, WithRefine1, WithUnknownContainers1 } from './Schemable'
 import Eq = E.Eq
@@ -173,6 +174,12 @@ export function lazy<A>(f: () => Eq<A>): Eq<A> {
   }
 }
 
+/**
+ * @category combinators
+ * @since 2.2.15
+ */
+export const readonly: <A>(eq: Eq<A>) => Eq<Readonly<A>> = identity
+
 // -------------------------------------------------------------------------------------
 // instances
 // -------------------------------------------------------------------------------------
@@ -195,7 +202,8 @@ export const Schemable: Schemable1<E.URI> = {
   tuple,
   intersect,
   sum,
-  lazy: (_, f) => lazy(f)
+  lazy: (_, f) => lazy(f),
+  readonly
 }
 
 /**
diff --git a/src/Guard.ts b/src/Guard.ts
@@ -8,7 +8,7 @@
  *
  * @since 2.2.0
  */
-import { Refinement } from 'fp-ts/lib/function'
+import { identity, Refinement } from 'fp-ts/lib/function'
 import { pipe } from 'fp-ts/lib/pipeable'
 import { Literal, memoize, Schemable1, WithRefine1, WithUnion1, WithUnknownContainers1 } from './Schemable'
 
@@ -243,6 +243,12 @@ export const lazy = <A>(f: () => Guard<unknown, A>): Guard<unknown, A> => {
   }
 }
 
+/**
+ * @category combinators
+ * @since 2.2.15
+ */
+export const readonly: <I, A extends I>(guard: Guard<I, A>) => Guard<I, Readonly<A>> = identity
+
 /**
  * @category combinators
  * @since 2.2.8
@@ -315,7 +321,8 @@ export const Schemable: Schemable1<URI> = {
   tuple: tuple as Schemable1<URI>['tuple'],
   intersect,
   sum,
-  lazy: (_, f) => lazy(f)
+  lazy: (_, f) => lazy(f),
+  readonly
 }
 
 /**
diff --git a/src/Schemable.ts b/src/Schemable.ts
@@ -36,6 +36,7 @@ export interface Schemable<S> {
     tag: T
   ) => <A>(members: { [K in keyof A]: HKT<S, A[K] & Record<T, K>> }) => HKT<S, A[keyof A]>
   readonly lazy: <A>(id: string, f: () => HKT<S, A>) => HKT<S, A>
+  readonly readonly: <A>(sa: HKT<S, A>) => HKT<S, Readonly<A>>
 }
 
 /**
@@ -58,6 +59,7 @@ export interface Schemable1<S extends URIS> {
     tag: T
   ) => <A>(members: { [K in keyof A]: Kind<S, A[K] & Record<T, K>> }) => Kind<S, A[keyof A]>
   readonly lazy: <A>(id: string, f: () => Kind<S, A>) => Kind<S, A>
+  readonly readonly: <A>(sa: Kind<S, A>) => Kind<S, Readonly<A>>
 }
 
 /**
@@ -84,6 +86,7 @@ export interface Schemable2C<S extends URIS2, E> {
     tag: T
   ) => <A>(members: { [K in keyof A]: Kind2<S, E, A[K] & Record<T, K>> }) => Kind2<S, E, A[keyof A]>
   readonly lazy: <A>(id: string, f: () => Kind2<S, E, A>) => Kind2<S, E, A>
+  readonly readonly: <A>(sa: Kind2<S, E, A>) => Kind2<S, E, Readonly<A>>
 }
 
 /**
diff --git a/src/TaskDecoder.ts b/src/TaskDecoder.ts
diff --git a/src/Type.ts b/src/Type.ts
diff --git a/test/Arbitrary.ts b/test/Arbitrary.ts
diff --git a/test/JsonSchema.ts b/test/JsonSchema.ts

Original file line number	Diff line number	Diff line change
`@@ -71,6 +71,7 @@ export interface Schemable<S> {`
`71`	`71`	`tag: T`
`72`	`72`	`) => <A>(members: { [K in keyof A]: HKT<S, A[K] & Record<T, K>> }) => HKT<S, A[keyof A]>`
`73`	`73`	`readonly lazy: <A>(id: string, f: () => HKT<S, A>) => HKT<S, A>`
	`74`	`+ readonly readonly: <A>(sa: HKT<S, A>) => HKT<S, Readonly<A>>`
`74`	`75`	`}`
`75`	`76`	```
`76`	`77`
`@@ -98,6 +99,7 @@ export interface Schemable1<S extends URIS> {`
`98`	`99`	`tag: T`
`99`	`100`	`) => <A>(members: { [K in keyof A]: Kind<S, A[K] & Record<T, K>> }) => Kind<S, A[keyof A]>`
`100`	`101`	`readonly lazy: <A>(id: string, f: () => Kind<S, A>) => Kind<S, A>`
	`102`	`+ readonly readonly: <A>(sa: Kind<S, A>) => Kind<S, Readonly<A>>`
`101`	`103`	`}`
`102`	`104`	```
`103`	`105`
`@@ -129,6 +131,7 @@ export interface Schemable2C<S extends URIS2, E> {`
`129`	`131`	`tag: T`
`130`	`132`	`) => <A>(members: { [K in keyof A]: Kind2<S, E, A[K] & Record<T, K>> }) => Kind2<S, E, A[keyof A]>`
`131`	`133`	`readonly lazy: <A>(id: string, f: () => Kind2<S, E, A>) => Kind2<S, E, A>`
	`134`	`+ readonly readonly: <A>(sa: Kind2<S, E, A>) => Kind2<S, E, Readonly<A>>`
`132`	`135`	`}`
`133`	`136`	```
`134`	`137`