io-ts - npm Package Compare versions

Comparing version 2.2.2 to 2.2.3

CHANGELOG.md

@@ -17,2 +17,27 @@ # Changelog
 
+# 2.2.3
+
+- **Polish**
+  - use the built-in `Readonly` type in `readonly` combinator, closes #472 (@gcanti)
+- **Experimental**
+  - split instances (@gcanti)
+  - add `Type` experimental module, #464 (@gcanti)
+  - restore the `O` type parameter to `Encoder`, #469 (@gcanti)
+  - add the `O` type parameter to `Codec` (@gcanti)
+  - add `JsonCodec` experimental module (@gcanti)
+  - add `JsonEncoder` experimental module (@gcanti)
+  - `Schemable`
+    - rename `Schemable` interface to `Schemable1` (@gcanti)
+    - rename `WithUnion` interface to `WithUnion1` (@gcanti)
+    - add `Schemable` interface (@gcanti)
+    - add `WithUnion` interface (@gcanti)
+    - add `WithRefinement` / `WithRefinement1` interfaces (@gcanti)
+    - add `WithUnknownContainers` / `WithUnknownContainers1` interfaces (@gcanti)
+      - move `UnknownArray` and `UnknownRecord` to `WithUnknownContainers` (@gcanti)
+  - `Schema`
+    - refactoring with the new `Schemable` interface (@gcanti)
+    - add `interpreter` function (@gcanti)
+- **Internal**
+  - upgrade to `typescript@3.9.3` (@gcanti)
+
 # 2.2.2
@@ -19,0 +44,0 @@

es6/Codec.d.ts

 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-import { Invariant1 } from 'fp-ts/es6/Invariant';
+import { Invariant2 } from 'fp-ts/es6/Invariant';
 import * as D from './Decoder';
 import * as E from './Encoder';
-import { Schemable, Literal } from './Schemable';
+import { Literal } from './Schemable';
 /**
@@ -14,106 +14,122 @@ * Laws:
  *
- * @since 2.2.0
+ * @since 2.2.3
  */
-export interface Codec<A> extends D.Decoder<A>, E.Encoder<A> {
+export interface Codec<O, A> extends D.Decoder<A>, E.Encoder<O, A> {
 }
 /**
- * @since 2.2.2
+ * @since 2.2.3
  */
-export declare type TypeOf<C> = C extends Codec<infer A> ? A : never;
+export declare type TypeOf<C> = E.TypeOf<C>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function make<A>(decoder: D.Decoder<A>, encoder: E.Encoder<A>): Codec<A>;
+export declare type OutputOf<C> = E.OutputOf<C>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function literal<A extends ReadonlyArray<Literal>>(...values: A): Codec<A[number]>;
+export declare function make<O, A>(decoder: D.Decoder<A>, encoder: E.Encoder<O, A>): Codec<O, A>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const string: Codec<string>;
+export declare function fromDecoder<A>(decoder: D.Decoder<A>): Codec<A, A>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const number: Codec<number>;
+export declare function literal<A extends ReadonlyArray<Literal>>(...values: A): Codec<A[number], A[number]>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const boolean: Codec<boolean>;
+export declare const string: Codec<string, string>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const UnknownArray: Codec<Array<unknown>>;
+export declare const number: Codec<number, number>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const UnknownRecord: Codec<Record<string, unknown>>;
+export declare const boolean: Codec<boolean, boolean>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function withExpected<A>(codec: Codec<A>, expected: (actual: unknown, e: D.DecodeError) => D.DecodeError): Codec<A>;
+export declare const UnknownArray: Codec<Array<unknown>, Array<unknown>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function refinement<A, B extends A>(from: Codec<A>, refinement: (a: A) => a is B, expected: string): Codec<B>;
+export declare const UnknownRecord: Codec<Record<string, unknown>, Record<string, unknown>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function nullable<A>(or: Codec<A>): Codec<null | A>;
+export declare function withExpected<O, A>(codec: Codec<O, A>, expected: (actual: unknown, e: D.DecodeError) => D.DecodeError): Codec<O, A>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function type<A>(properties: {
-    [K in keyof A]: Codec<A[K]>;
-}): Codec<A>;
+export declare function refinement<O, A, B extends A>(from: Codec<O, A>, refinement: (a: A) => a is B, expected: string): Codec<O, B>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function partial<A>(properties: {
-    [K in keyof A]: Codec<A[K]>;
-}): Codec<Partial<A>>;
+export declare function nullable<O, A>(or: Codec<O, A>): Codec<null | O, null | A>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function record<A>(codomain: Codec<A>): Codec<Record<string, A>>;
+export declare function type<P extends Record<string, Codec<any, any>>>(properties: P): Codec<{
+    [K in keyof P]: OutputOf<P[K]>;
+}, {
+    [K in keyof P]: TypeOf<P[K]>;
+}>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function array<A>(items: Codec<A>): Codec<Array<A>>;
+export declare function partial<P extends Record<string, Codec<any, any>>>(properties: P): Codec<Partial<{
+    [K in keyof P]: OutputOf<P[K]>;
+}>, Partial<{
+    [K in keyof P]: TypeOf<P[K]>;
+}>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function tuple<A extends ReadonlyArray<unknown>>(...components: {
-    [K in keyof A]: Codec<A[K]>;
-}): Codec<A>;
+export declare function record<O, A>(codomain: Codec<O, A>): Codec<Record<string, O>, Record<string, A>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function intersection<A, B>(left: Codec<A>, right: Codec<B>): Codec<A & B>;
+export declare function array<O, A>(items: Codec<O, A>): Codec<Array<O>, Array<A>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function sum<T extends string>(tag: T): <A>(members: {
-    [K in keyof A]: Codec<A[K] & Record<T, K>>;
-}) => Codec<A[keyof A]>;
+export declare function tuple<C extends ReadonlyArray<Codec<any, any>>>(...components: C): Codec<{
+    [K in keyof C]: OutputOf<C[K]>;
+}, {
+    [K in keyof C]: TypeOf<C[K]>;
+}>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function lazy<A>(id: string, f: () => Codec<A>): Codec<A>;
+export declare function intersection<O, A, P, B>(left: Codec<O, A>, right: Codec<P, B>): Codec<O & P, A & B>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const URI = "Codec";
+export declare function sum<T extends string>(tag: T): <M extends Record<string, Codec<any, any>>>(members: M) => Codec<OutputOf<M[keyof M]>, TypeOf<M[keyof M]>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
+export declare function lazy<O, A>(id: string, f: () => Codec<O, A>): Codec<O, A>;
+/**
+ * @since 2.2.3
+ */
+export declare const imap: <E, A, B>(f: (a: A) => B, g: (b: B) => A) => (fa: Codec<E, A>) => Codec<E, B>;
+/**
+ * @since 2.2.3
+ */
+export declare const URI = "io-ts/Codec";
+/**
+ * @since 2.2.3
+ */
 export declare type URI = typeof URI;
 declare module 'fp-ts/es6/HKT' {
-    interface URItoKind<A> {
-        readonly Codec: Codec<A>;
+    interface URItoKind2<E, A> {
+        readonly [URI]: Codec<E, A>;
     }
 }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const codec: Invariant1<URI> & Schemable<URI>;
+export declare const invariantCodec: Invariant2<URI>;

es6/Codec.js

 import * as D from './Decoder';
 import * as E from './Encoder';
+import { identity } from 'fp-ts/es6/function';
 // -------------------------------------------------------------------------------------
@@ -7,3 +8,3 @@ // constructors
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -17,6 +18,14 @@ export function make(decoder, encoder) {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
+export function fromDecoder(decoder) {
+    return {
+        decode: decoder.decode,
+        encode: identity
+    };
+}
+/**
+ * @since 2.2.3
+ */
 export function literal() {
-    var _a, _b;
     var values = [];
@@ -26,3 +35,3 @@ for (var _i = 0; _i < arguments.length; _i++) {
     }
-    return make((_a = D.decoder).literal.apply(_a, values), (_b = E.encoder).literal.apply(_b, values));
+    return fromDecoder(D.literal.apply(D, values));
 }
@@ -33,21 +42,21 @@ // -------------------------------------------------------------------------------------
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export var string = make(D.decoder.string, E.encoder.string);
+export var string = fromDecoder(D.string);
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export var number = make(D.decoder.number, E.encoder.number);
+export var number = fromDecoder(D.number);
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export var boolean = make(D.decoder.boolean, E.encoder.boolean);
+export var boolean = fromDecoder(D.boolean);
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export var UnknownArray = make(D.decoder.UnknownArray, E.encoder.UnknownArray);
+export var UnknownArray = fromDecoder(D.UnknownArray);
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export var UnknownRecord = make(D.decoder.UnknownRecord, E.encoder.UnknownRecord);
+export var UnknownRecord = fromDecoder(D.UnknownRecord);
 // -------------------------------------------------------------------------------------
@@ -57,3 +66,3 @@ // combinators
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -64,3 +73,3 @@ export function withExpected(codec, expected) {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -71,36 +80,36 @@ export function refinement(from, refinement, expected) {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 export function nullable(or) {
-    return make(D.decoder.nullable(or), E.encoder.nullable(or));
+    return make(D.nullable(or), E.nullable(or));
 }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 export function type(properties) {
-    return make(D.decoder.type(properties), E.encoder.type(properties));
+    var decoder = D.type(properties);
+    return make(decoder, E.type(properties));
 }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 export function partial(properties) {
-    return make(D.decoder.partial(properties), E.encoder.partial(properties));
+    return make(D.partial(properties), E.partial(properties));
 }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 export function record(codomain) {
-    return make(D.decoder.record(codomain), E.encoder.record(codomain));
+    return make(D.record(codomain), E.record(codomain));
 }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 export function array(items) {
-    return make(D.decoder.array(items), E.encoder.array(items));
+    return make(D.array(items), E.array(items));
 }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 export function tuple() {
-    var _a, _b;
     var components = [];
@@ -110,52 +119,51 @@ for (var _i = 0; _i < arguments.length; _i++) {
     }
-    return make((_a = D.decoder).tuple.apply(_a, components), (_b = E.encoder).tuple.apply(_b, components));
+    var decoder = D.tuple.apply(D, components);
+    var encoder = E.tuple.apply(E, components);
+    return make(decoder, encoder);
 }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 export function intersection(left, right) {
-    return make(D.decoder.intersection(left, right), E.encoder.intersection(left, right));
+    return make(D.intersection(left, right), E.intersection(left, right));
 }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 export function sum(tag) {
-    var sumD = D.decoder.sum(tag);
-    var sumE = E.encoder.sum(tag);
+    var sumD = D.sum(tag);
+    var sumE = E.sum(tag);
     return function (members) { return make(sumD(members), sumE(members)); };
 }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 export function lazy(id, f) {
-    return make(D.decoder.lazy(id, f), E.encoder.lazy(id, f));
+    return make(D.lazy(id, f), E.lazy(f));
 }
 // -------------------------------------------------------------------------------------
+// pipeables
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.2.3
+ */
+export var imap = function (f, g) { return function (fa) {
+    return imap_(fa, f, g);
+}; };
+var imap_ = function (fa, f, g) {
+    return make(D.functorDecoder.map(fa, f), E.contravariantEncoder.contramap(fa, g));
+};
+// -------------------------------------------------------------------------------------
 // instances
 // -------------------------------------------------------------------------------------
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export var URI = 'Codec';
+export var URI = 'io-ts/Codec';
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export var codec = {
+export var invariantCodec = {
     URI: URI,
-    imap: function (fa, f, g) { return make(D.decoder.map(fa, f), E.encoder.contramap(fa, g)); },
-    literal: literal,
-    string: string,
-    number: number,
-    boolean: boolean,
-    UnknownArray: UnknownArray,
-    UnknownRecord: UnknownRecord,
-    nullable: nullable,
-    type: type,
-    partial: partial,
-    record: record,
-    array: array,
-    tuple: tuple,
-    intersection: intersection,
-    sum: sum,
-    lazy: lazy
+    imap: imap_
 };

es6/Decoder.d.ts

 /**
  * @since 2.2.0
  */
-import { Alternative1 } from 'fp-ts/es6/Alternative';
-import { Applicative1 } from 'fp-ts/es6/Applicative';
 import { Either } from 'fp-ts/es6/Either';
 import { NonEmptyArray } from 'fp-ts/es6/NonEmptyArray';
-import { Tree, Forest } from 'fp-ts/es6/Tree';
+import { Forest, Tree } from 'fp-ts/es6/Tree';
 import * as G from './Guard';
-import { Schemable, WithUnion, Literal } from './Schemable';
+import { Literal, Schemable1, WithRefinement1, WithUnion1, WithUnknownContainers1 } from './Schemable';
+import { Functor1 } from 'fp-ts/es6/Functor';
+import { Alt1 } from 'fp-ts/es6/Alt';
 /**
@@ -43,2 +43,6 @@ * @since 2.2.2
 /**
+ * @since 2.2.3
+ */
+export declare function of<A>(a: A): Decoder<A>;
+/**
  * @since 2.2.0
@@ -129,3 +133,3 @@ */
 export declare function sum<T extends string>(tag: T): <A>(members: {
-    [K in keyof A]: Decoder<A[K] & Record<T, K>>;
+    [K in keyof A]: Decoder<A[K]>;
 }) => Decoder<A[keyof A]>;
@@ -141,37 +145,31 @@ /**
  */
-export declare const URI = "Decoder";
+export declare const map: <A, B>(f: (a: A) => B) => (fa: Decoder<A>) => Decoder<B>;
 /**
  * @since 2.2.0
  */
-export declare type URI = typeof URI;
-declare module 'fp-ts/es6/HKT' {
-    interface URItoKind<A> {
-        readonly Decoder: Decoder<A>;
-    }
-}
+export declare const alt: <A>(that: () => Decoder<A>) => (fa: Decoder<A>) => Decoder<A>;
 /**
  * @since 2.2.0
  */
-export declare const decoder: Applicative1<URI> & Alternative1<URI> & Schemable<URI> & WithUnion<URI>;
-declare const alt: <A>(that: () => Decoder<A>) => (fa: Decoder<A>) => Decoder<A>, ap: <A>(fa: Decoder<A>) => <B>(fab: Decoder<(a: A) => B>) => Decoder<B>, apFirst: <B>(fb: Decoder<B>) => <A>(fa: Decoder<A>) => Decoder<A>, apSecond: <B>(fb: Decoder<B>) => <A>(fa: Decoder<A>) => Decoder<B>, map: <A, B>(f: (a: A) => B) => (fa: Decoder<A>) => Decoder<B>;
-export { 
+export declare const URI = "io-ts/Decoder";
 /**
  * @since 2.2.0
  */
-alt, 
+export declare type URI = typeof URI;
+declare module 'fp-ts/es6/HKT' {
+    interface URItoKind<A> {
+        readonly [URI]: Decoder<A>;
+    }
+}
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-ap, 
+export declare const functorDecoder: Functor1<URI>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-apFirst, 
+export declare const altDecoder: Alt1<URI>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-apSecond, 
-/**
- * @since 2.2.0
- */
-map };
+export declare const schemableDecoder: Schemable1<URI> & WithUnknownContainers1<URI> & WithUnion1<URI> & WithRefinement1<URI>;

es6/Decoder.js

@@ -1,7 +0,10 @@
-import { either, isLeft, isRight, left, mapLeft, right } from 'fp-ts/es6/Either';
-import { pipe, pipeable } from 'fp-ts/es6/pipeable';
+/**
+ * @since 2.2.0
+ */
+import { isLeft, isRight, left, mapLeft, right } from 'fp-ts/es6/Either';
+import { pipe } from 'fp-ts/es6/pipeable';
 import * as G from './Guard';
 import { memoize } from './Schemable';
 // -------------------------------------------------------------------------------------
-// constructors
+// DecodeError
 // -------------------------------------------------------------------------------------
@@ -37,3 +40,14 @@ var empty = [];
 }
+// -------------------------------------------------------------------------------------
+// constructors
+// -------------------------------------------------------------------------------------
 /**
+ * @since 2.2.3
+ */
+export function of(a) {
+    return {
+        decode: function () { return success(a); }
+    };
+}
+/**
  * @since 2.2.0
@@ -59,3 +73,3 @@ */
     var expected = values.map(function (value) { return JSON.stringify(value); }).join(' | ');
-    return fromGuard((_a = G.guard).literal.apply(_a, values), expected);
+    return fromGuard((_a = G.schemableGuard).literal.apply(_a, values), expected);
 }
@@ -403,3 +417,3 @@ // -------------------------------------------------------------------------------------
 // -------------------------------------------------------------------------------------
-// instances
+// pipeables
 // -------------------------------------------------------------------------------------
@@ -409,21 +423,46 @@ /**
  */
-export var URI = 'Decoder';
+export var map = function (f) { return function (fa) { return map_(fa, f); }; };
+var map_ = function (fa, f) { return ({
+    decode: function (u) {
+        var e = fa.decode(u);
+        return isLeft(e) ? e : right(f(e.right));
+    }
+}); };
 /**
  * @since 2.2.0
  */
-export var decoder = {
+export var alt = function (that) { return function (fa) { return alt_(fa, that); }; };
+var alt_ = function (fx, fy) { return ({
+    decode: function (u) {
+        var e = fx.decode(u);
+        return isLeft(e) ? fy().decode(u) : e;
+    }
+}); };
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.2.0
+ */
+export var URI = 'io-ts/Decoder';
+/**
+ * @since 2.2.3
+ */
+export var functorDecoder = {
     URI: URI,
-    map: function (fa, f) { return ({
-        decode: function (u) { return either.map(fa.decode(u), f); }
-    }); },
-    of: function (a) { return ({
-        decode: function () { return success(a); }
-    }); },
-    ap: function (fab, fa) { return ({
-        decode: function (u) { return either.ap(fab.decode(u), fa.decode(u)); }
-    }); },
-    alt: function (fx, fy) { return ({
-        decode: function (u) { return either.alt(fx.decode(u), function () { return fy().decode(u); }); }
-    }); },
-    zero: function () { return never; },
+    map: map_
+};
+/**
+ * @since 2.2.3
+ */
+export var altDecoder = {
+    URI: URI,
+    map: map_,
+    alt: alt_
+};
+/**
+ * @since 2.2.3
+ */
+export var schemableDecoder = {
+    URI: URI,
     literal: literal,
@@ -433,4 +472,2 @@ string: string,
     boolean: boolean,
-    UnknownArray: UnknownArray,
-    UnknownRecord: UnknownRecord,
     nullable: nullable,
@@ -445,25 +482,6 @@ type: type,
     lazy: lazy,
-    union: union
+    UnknownArray: UnknownArray,
+    UnknownRecord: UnknownRecord,
+    union: union,
+    refinement: refinement
 };
-var _a = pipeable(decoder), alt = _a.alt, ap = _a.ap, apFirst = _a.apFirst, apSecond = _a.apSecond, map = _a.map;
-export { 
-/**
- * @since 2.2.0
- */
-alt, 
-/**
- * @since 2.2.0
- */
-ap, 
-/**
- * @since 2.2.0
- */
-apFirst, 
-/**
- * @since 2.2.0
- */
-apSecond, 
-/**
- * @since 2.2.0
- */
-map };

es6/Encoder.d.ts

 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-import { Contravariant1 } from 'fp-ts/es6/Contravariant';
-import { Schemable } from './Schemable';
+import { Contravariant2 } from 'fp-ts/es6/Contravariant';
+import { Category2 } from 'fp-ts/es6/Category';
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export interface Encoder<A> {
-    readonly encode: (a: A) => unknown;
+export interface Encoder<O, A> {
+    readonly encode: (a: A) => O;
 }
 /**
- * @since 2.2.2
+ * @since 2.2.3
  */
-export declare type TypeOf<E> = E extends Encoder<infer A> ? A : never;
+export declare type TypeOf<E> = E extends Encoder<any, infer A> ? A : never;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const id: Encoder<unknown>;
+export declare type OutputOf<E> = E extends Encoder<infer O, any> ? O : never;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function nullable<A>(or: Encoder<A>): Encoder<null | A>;
+export declare function id<A>(): Encoder<A, A>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function type<A>(properties: {
-    [K in keyof A]: Encoder<A[K]>;
-}): Encoder<A>;
+export declare function nullable<O, A>(or: Encoder<O, A>): Encoder<null | O, null | A>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function partial<A>(properties: {
-    [K in keyof A]: Encoder<A[K]>;
-}): Encoder<Partial<A>>;
+export declare function type<P extends Record<string, Encoder<any, any>>>(properties: P): Encoder<{
+    [K in keyof P]: OutputOf<P[K]>;
+}, {
+    [K in keyof P]: TypeOf<P[K]>;
+}>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function record<A>(codomain: Encoder<A>): Encoder<Record<string, A>>;
+export declare function partial<P extends Record<string, Encoder<any, any>>>(properties: P): Encoder<Partial<{
+    [K in keyof P]: OutputOf<P[K]>;
+}>, Partial<{
+    [K in keyof P]: TypeOf<P[K]>;
+}>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function array<A>(items: Encoder<A>): Encoder<Array<A>>;
+export declare function record<O, A>(codomain: Encoder<O, A>): Encoder<Record<string, O>, Record<string, A>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function tuple<A extends ReadonlyArray<unknown>>(...components: {
-    [K in keyof A]: Encoder<A[K]>;
-}): Encoder<A>;
+export declare function array<O, A>(items: Encoder<O, A>): Encoder<Array<O>, Array<A>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function intersection<A, B>(left: Encoder<A>, right: Encoder<B>): Encoder<A & B>;
+export declare function tuple<C extends ReadonlyArray<Encoder<any, any>>>(...components: C): Encoder<{
+    [K in keyof C]: OutputOf<C[K]>;
+}, {
+    [K in keyof C]: TypeOf<C[K]>;
+}>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function sum<T extends string>(tag: T): <A>(members: {
-    [K in keyof A]: Encoder<A[K] & Record<T, K>>;
-}) => Encoder<A[keyof A]>;
+export declare function intersection<O, A, P, B>(left: Encoder<O, A>, right: Encoder<P, B>): Encoder<O & P, A & B>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function lazy<A>(f: () => Encoder<A>): Encoder<A>;
+export declare function sum<T extends string>(tag: T): <M extends Record<string, Encoder<any, any>>>(members: M) => Encoder<OutputOf<M[keyof M]>, TypeOf<M[keyof M]>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const URI = "Encoder";
+export declare function lazy<O, A>(f: () => Encoder<O, A>): Encoder<O, A>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
+export declare const contramap: <A, B>(f: (b: B) => A) => <E>(fa: Encoder<E, A>) => Encoder<E, B>;
+/**
+ * @since 2.2.3
+ */
+export declare const compose: <E, A>(ea: Encoder<E, A>) => <B>(ab: Encoder<A, B>) => Encoder<E, B>;
+/**
+ * @since 2.2.3
+ */
+export declare const URI = "io-ts/Encoder";
+/**
+ * @since 2.2.3
+ */
 export declare type URI = typeof URI;
 declare module 'fp-ts/es6/HKT' {
-    interface URItoKind<A> {
-        readonly Encoder: Encoder<A>;
+    interface URItoKind2<E, A> {
+        readonly [URI]: Encoder<E, A>;
     }
 }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const encoder: Contravariant1<URI> & Schemable<URI>;
-declare const contramap: <A, B>(f: (b: B) => A) => (fa: Encoder<A>) => Encoder<B>;
-export { 
+export declare const contravariantEncoder: Contravariant2<URI>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-contramap };
+export declare const categoryEncoder: Category2<URI>;

es6/Encoder.js

@@ -0,14 +1,15 @@
+import { intersect } from './Decoder';
+import { memoize } from './Schemable';
 import { identity } from 'fp-ts/es6/function';
-import { pipeable } from 'fp-ts/es6/pipeable';
-import { memoize } from './Schemable';
-import { intersect } from './Decoder';
 // -------------------------------------------------------------------------------------
-// primitives
+// constructors
 // -------------------------------------------------------------------------------------
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export var id = {
-    encode: identity
-};
+export function id() {
+    return {
+        encode: identity
+    };
+}
 // -------------------------------------------------------------------------------------
@@ -18,11 +19,11 @@ // combinators
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 export function nullable(or) {
     return {
-        encode: function (a) { return (a === null ? a : or.encode(a)); }
+        encode: function (a) { return (a === null ? null : or.encode(a)); }
     };
 }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -41,3 +42,3 @@ export function type(properties) {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -53,3 +54,3 @@ export function partial(properties) {
                     // don't strip undefined properties
-                    o[k] = v === undefined ? v : properties[k].encode(v);
+                    o[k] = v === undefined ? undefined : properties[k].encode(v);
                 }
@@ -62,3 +63,3 @@ }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -77,3 +78,3 @@ export function record(codomain) {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -86,3 +87,3 @@ export function array(items) {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -99,3 +100,3 @@ export function tuple() {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -108,3 +109,3 @@ export function intersection(left, right) {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -119,3 +120,3 @@ export function sum(tag) {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -129,37 +130,43 @@ export function lazy(f) {
 // -------------------------------------------------------------------------------------
+// pipeables
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.2.3
+ */
+export var contramap = function (f) { return function (fa) {
+    return contramap_(fa, f);
+}; };
+var contramap_ = function (fa, f) { return ({
+    encode: function (b) { return fa.encode(f(b)); }
+}); };
+/**
+ * @since 2.2.3
+ */
+export var compose = function (ea) { return function (ab) {
+    return compose_(ab, ea);
+}; };
+var compose_ = function (ab, ea) { return ({
+    encode: function (b) { return ea.encode(ab.encode(b)); }
+}); };
+// -------------------------------------------------------------------------------------
 // instances
 // -------------------------------------------------------------------------------------
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export var URI = 'Encoder';
+export var URI = 'io-ts/Encoder';
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export var encoder = {
+export var contravariantEncoder = {
     URI: URI,
-    contramap: function (fa, f) { return ({
-        encode: function (b) { return fa.encode(f(b)); }
-    }); },
-    literal: function () { return id; },
-    string: id,
-    number: id,
-    boolean: id,
-    UnknownArray: id,
-    UnknownRecord: id,
-    nullable: nullable,
-    type: type,
-    partial: partial,
-    record: record,
-    array: array,
-    tuple: tuple,
-    intersection: intersection,
-    sum: sum,
-    lazy: function (_, f) { return lazy(f); }
+    contramap: contramap_
 };
-var contramap = pipeable(encoder).contramap;
-export { 
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-contramap };
+export var categoryEncoder = {
+    URI: URI,
+    compose: compose_,
+    id: id
+};

es6/Eq.d.ts

 import * as E from 'fp-ts/es6/Eq';
-import * as S from './Schemable';
+import { Schemable1, WithRefinement1, WithUnknownContainers1 } from './Schemable';
 import Eq = E.Eq;
 /**
+ * @since 2.2.3
+ */
+export declare type URI = E.URI;
+/**
  * @since 2.2.2
@@ -66,3 +70,3 @@ */
 export declare function sum<T extends string>(tag: T): <A>(members: {
-    [K in keyof A]: Eq<A[K] & Record<T, K>>;
+    [K in keyof A]: Eq<A[K]>;
 }) => Eq<A[keyof A]>;
@@ -74,4 +78,4 @@ /**
 /**
- * @since 2.2.2
+ * @since 2.2.3
  */
-export declare const eq: typeof E.eq & S.Schemable<E.URI>;
+export declare const schemableEq: Schemable1<E.URI> & WithUnknownContainers1<E.URI> & WithRefinement1<E.URI>;

es6/Eq.js

@@ -1,12 +0,1 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 /**
@@ -18,3 +7,3 @@ * @since 2.2.2
 import * as R from 'fp-ts/es6/Record';
-import * as S from './Schemable';
+import { memoize } from './Schemable';
 // -------------------------------------------------------------------------------------
@@ -128,3 +117,3 @@ // primitives
 export function lazy(f) {
-    var get = S.memoize(f);
+    var get = memoize(f);
     return {
@@ -134,10 +123,14 @@ equals: function (x, y) { return get().equals(x, y); }
 }
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
 /**
- * @since 2.2.2
+ * @since 2.2.3
  */
-export var eq = __assign(__assign({}, E.eq), { literal: function () { return E.eqStrict; }, string: string,
+export var schemableEq = {
+    URI: E.URI,
+    literal: function () { return E.eqStrict; },
+    string: string,
     number: number,
     boolean: boolean,
-    UnknownArray: UnknownArray,
-    UnknownRecord: UnknownRecord,
     nullable: nullable,
@@ -150,2 +143,7 @@ type: type,
     intersection: intersection,
-    sum: sum, lazy: function (_, f) { return lazy(f); } });
+    sum: sum,
+    lazy: function (_, f) { return lazy(f); },
+    UnknownArray: UnknownArray,
+    UnknownRecord: UnknownRecord,
+    refinement: function (from) { return from; }
+};

es6/Guard.d.ts

 /**
  * @since 2.2.0
  */
-import { Schemable, WithUnion, Literal } from './Schemable';
+import { Literal, Schemable1, WithRefinement1, WithUnion1, WithUnknownContainers1 } from './Schemable';
 /**
@@ -91,3 +91,3 @@ * @since 2.2.0
 export declare function sum<T extends string>(tag: T): <A>(members: {
-    [K in keyof A]: Guard<A[K] & Record<T, K>>;
+    [K in keyof A]: Guard<A[K]>;
 }) => Guard<A[keyof A]>;
@@ -101,3 +101,3 @@ /**
  */
-export declare const URI = "Guard";
+export declare const URI = "io-ts/Guard";
 /**
@@ -109,8 +109,8 @@ * @since 2.2.0
     interface URItoKind<A> {
-        readonly Guard: Guard<A>;
+        readonly [URI]: Guard<A>;
     }
 }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const guard: Schemable<URI> & WithUnion<URI>;
+export declare const schemableGuard: Schemable1<URI> & WithUnknownContainers1<URI> & WithUnion1<URI> & WithRefinement1<URI>;

es6/Guard.js

@@ -185,7 +185,7 @@ /**
  */
-export var URI = 'Guard';
+export var URI = 'io-ts/Guard';
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export var guard = {
+export var schemableGuard = {
     URI: URI,
@@ -196,4 +196,2 @@ literal: literal,
     boolean: boolean,
-    UnknownArray: UnknownArray,
-    UnknownRecord: UnknownRecord,
     nullable: nullable,
@@ -208,3 +206,6 @@ type: type,
     lazy: function (_, f) { return lazy(f); },
-    union: union
+    UnknownArray: UnknownArray,
+    UnknownRecord: UnknownRecord,
+    union: union,
+    refinement: refinement
 };

es6/index.d.ts

@@ -753,7 +753,3 @@ /**
  */
-export interface ReadonlyC<C extends Mixed> extends ReadonlyType<C, {
-    readonly [K in keyof TypeOf<C>]: TypeOf<C>[K];
-}, {
-    readonly [K in keyof OutputOf<C>]: OutputOf<C>[K];
-}, unknown> {
+export interface ReadonlyC<C extends Mixed> extends ReadonlyType<C, Readonly<TypeOf<C>>, Readonly<OutputOf<C>>, unknown> {
 }
@@ -760,0 +756,0 @@ /**

es6/Schema.d.ts

 /**
  * @since 2.2.0
  */
-import { Kind, URIS } from 'fp-ts/es6/HKT';
-import { Schemable } from './Schemable';
+import { HKT, URIS, Kind } from 'fp-ts/es6/HKT';
+import { Schemable, Schemable1 } from './Schemable';
 /**
@@ -10,3 +10,3 @@ * @since 2.2.0
 export interface Schema<A> {
-    <S extends URIS>(S: Schemable<S>): Kind<S, A>;
+    <S>(S: Schemable<S>): HKT<S, A>;
 }
@@ -20,2 +20,6 @@ /**
  */
-export declare function make<A>(f: Schema<A>): Schema<A>;
+export declare function make<A>(schema: Schema<A>): Schema<A>;
+/**
+ * @since 2.2.3
+ */
+export declare function interpreter<S extends URIS>(S: Schemable1<S>): <A>(schema: Schema<A>) => Kind<S, A>;

es6/Schema.js

@@ -5,4 +5,10 @@ import { memoize } from './Schemable';
  */
-export function make(f) {
-    return memoize(f);
+export function make(schema) {
+    return memoize(schema);
 }
+/**
+ * @since 2.2.3
+ */
+export function interpreter(S) {
+    return function (schema) { return schema(S); };
+}

es6/Schemable.d.ts

 /**
  * @since 2.2.0
  */
-import { Kind, URIS } from 'fp-ts/es6/HKT';
+import { Kind, URIS, HKT } from 'fp-ts/es6/HKT';
 /**
@@ -10,6 +10,33 @@ * @since 2.2.0
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export interface Schemable<S extends URIS> {
+export interface Schemable<S> {
     readonly URI: S;
+    readonly literal: <A extends ReadonlyArray<Literal>>(...values: A) => HKT<S, A[number]>;
+    readonly string: HKT<S, string>;
+    readonly number: HKT<S, number>;
+    readonly boolean: HKT<S, boolean>;
+    readonly nullable: <A>(or: HKT<S, A>) => HKT<S, null | A>;
+    readonly type: <A>(properties: {
+        [K in keyof A]: HKT<S, A[K]>;
+    }) => HKT<S, A>;
+    readonly partial: <A>(properties: {
+        [K in keyof A]: HKT<S, A[K]>;
+    }) => HKT<S, Partial<A>>;
+    readonly record: <A>(codomain: HKT<S, A>) => HKT<S, Record<string, A>>;
+    readonly array: <A>(items: HKT<S, A>) => HKT<S, Array<A>>;
+    readonly tuple: <A extends ReadonlyArray<unknown>>(...components: {
+        [K in keyof A]: HKT<S, A[K]>;
+    }) => HKT<S, A>;
+    readonly intersection: <A, B>(left: HKT<S, A>, right: HKT<S, B>) => HKT<S, A & B>;
+    readonly sum: <T extends string>(tag: T) => <A>(members: {
+        [K in keyof A]: HKT<S, A[K]>;
+    }) => HKT<S, A[keyof A]>;
+    readonly lazy: <A>(id: string, f: () => HKT<S, A>) => HKT<S, A>;
+}
+/**
+ * @since 2.2.3
+ */
+export interface Schemable1<S extends URIS> {
+    readonly URI: S;
     readonly literal: <A extends ReadonlyArray<Literal>>(...values: A) => Kind<S, A[number]>;
@@ -19,4 +46,2 @@ readonly string: Kind<S, string>;
     readonly boolean: Kind<S, boolean>;
-    readonly UnknownArray: Kind<S, Array<unknown>>;
-    readonly UnknownRecord: Kind<S, Record<string, unknown>>;
     readonly nullable: <A>(or: Kind<S, A>) => Kind<S, null | A>;
@@ -36,3 +61,3 @@ readonly type: <A>(properties: {
     readonly sum: <T extends string>(tag: T) => <A>(members: {
-        [K in keyof A]: Kind<S, A[K] & Record<T, K>>;
+        [K in keyof A]: Kind<S, A[K]>;
     }) => Kind<S, A[keyof A]>;
@@ -42,6 +67,28 @@ readonly lazy: <A>(id: string, f: () => Kind<S, A>) => Kind<S, A>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export interface WithUnion<S extends URIS> {
+export interface WithUnknownContainers<S> {
+    readonly UnknownArray: HKT<S, Array<unknown>>;
+    readonly UnknownRecord: HKT<S, Record<string, unknown>>;
+}
+/**
+ * @since 2.2.3
+ */
+export interface WithUnknownContainers1<S extends URIS> {
+    readonly UnknownArray: Kind<S, Array<unknown>>;
+    readonly UnknownRecord: Kind<S, Record<string, unknown>>;
+}
+/**
+ * @since 2.2.3
+ */
+export interface WithUnion<S> {
     readonly union: <A extends ReadonlyArray<unknown>>(...members: {
+        [K in keyof A]: HKT<S, A[K]>;
+    }) => HKT<S, A[number]>;
+}
+/**
+ * @since 2.2.3
+ */
+export interface WithUnion1<S extends URIS> {
+    readonly union: <A extends ReadonlyArray<unknown>>(...members: {
         [K in keyof A]: Kind<S, A[K]>;
@@ -51,4 +98,16 @@ }) => Kind<S, A[number]>;
 /**
+ * @since 2.2.3
+ */
+export interface WithRefinement<S> {
+    readonly refinement: <A, B extends A>(from: HKT<S, A>, refinement: (a: A) => a is B, expected: string) => HKT<S, B>;
+}
+/**
+ * @since 2.2.3
+ */
+export interface WithRefinement1<S extends URIS> {
+    readonly refinement: <A, B extends A>(from: Kind<S, A>, refinement: (a: A) => a is B, expected: string) => Kind<S, B>;
+}
+/**
  * @since 2.2.0
  */
 export declare function memoize<A, B>(f: (a: A) => B): (a: A) => B;

lib/Codec.d.ts

 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-import { Invariant1 } from 'fp-ts/lib/Invariant';
+import { Invariant2 } from 'fp-ts/lib/Invariant';
 import * as D from './Decoder';
 import * as E from './Encoder';
-import { Schemable, Literal } from './Schemable';
+import { Literal } from './Schemable';
 /**
@@ -14,106 +14,122 @@ * Laws:
  *
- * @since 2.2.0
+ * @since 2.2.3
  */
-export interface Codec<A> extends D.Decoder<A>, E.Encoder<A> {
+export interface Codec<O, A> extends D.Decoder<A>, E.Encoder<O, A> {
 }
 /**
- * @since 2.2.2
+ * @since 2.2.3
  */
-export declare type TypeOf<C> = C extends Codec<infer A> ? A : never;
+export declare type TypeOf<C> = E.TypeOf<C>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function make<A>(decoder: D.Decoder<A>, encoder: E.Encoder<A>): Codec<A>;
+export declare type OutputOf<C> = E.OutputOf<C>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function literal<A extends ReadonlyArray<Literal>>(...values: A): Codec<A[number]>;
+export declare function make<O, A>(decoder: D.Decoder<A>, encoder: E.Encoder<O, A>): Codec<O, A>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const string: Codec<string>;
+export declare function fromDecoder<A>(decoder: D.Decoder<A>): Codec<A, A>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const number: Codec<number>;
+export declare function literal<A extends ReadonlyArray<Literal>>(...values: A): Codec<A[number], A[number]>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const boolean: Codec<boolean>;
+export declare const string: Codec<string, string>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const UnknownArray: Codec<Array<unknown>>;
+export declare const number: Codec<number, number>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const UnknownRecord: Codec<Record<string, unknown>>;
+export declare const boolean: Codec<boolean, boolean>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function withExpected<A>(codec: Codec<A>, expected: (actual: unknown, e: D.DecodeError) => D.DecodeError): Codec<A>;
+export declare const UnknownArray: Codec<Array<unknown>, Array<unknown>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function refinement<A, B extends A>(from: Codec<A>, refinement: (a: A) => a is B, expected: string): Codec<B>;
+export declare const UnknownRecord: Codec<Record<string, unknown>, Record<string, unknown>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function nullable<A>(or: Codec<A>): Codec<null | A>;
+export declare function withExpected<O, A>(codec: Codec<O, A>, expected: (actual: unknown, e: D.DecodeError) => D.DecodeError): Codec<O, A>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function type<A>(properties: {
-    [K in keyof A]: Codec<A[K]>;
-}): Codec<A>;
+export declare function refinement<O, A, B extends A>(from: Codec<O, A>, refinement: (a: A) => a is B, expected: string): Codec<O, B>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function partial<A>(properties: {
-    [K in keyof A]: Codec<A[K]>;
-}): Codec<Partial<A>>;
+export declare function nullable<O, A>(or: Codec<O, A>): Codec<null | O, null | A>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function record<A>(codomain: Codec<A>): Codec<Record<string, A>>;
+export declare function type<P extends Record<string, Codec<any, any>>>(properties: P): Codec<{
+    [K in keyof P]: OutputOf<P[K]>;
+}, {
+    [K in keyof P]: TypeOf<P[K]>;
+}>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function array<A>(items: Codec<A>): Codec<Array<A>>;
+export declare function partial<P extends Record<string, Codec<any, any>>>(properties: P): Codec<Partial<{
+    [K in keyof P]: OutputOf<P[K]>;
+}>, Partial<{
+    [K in keyof P]: TypeOf<P[K]>;
+}>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function tuple<A extends ReadonlyArray<unknown>>(...components: {
-    [K in keyof A]: Codec<A[K]>;
-}): Codec<A>;
+export declare function record<O, A>(codomain: Codec<O, A>): Codec<Record<string, O>, Record<string, A>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function intersection<A, B>(left: Codec<A>, right: Codec<B>): Codec<A & B>;
+export declare function array<O, A>(items: Codec<O, A>): Codec<Array<O>, Array<A>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function sum<T extends string>(tag: T): <A>(members: {
-    [K in keyof A]: Codec<A[K] & Record<T, K>>;
-}) => Codec<A[keyof A]>;
+export declare function tuple<C extends ReadonlyArray<Codec<any, any>>>(...components: C): Codec<{
+    [K in keyof C]: OutputOf<C[K]>;
+}, {
+    [K in keyof C]: TypeOf<C[K]>;
+}>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function lazy<A>(id: string, f: () => Codec<A>): Codec<A>;
+export declare function intersection<O, A, P, B>(left: Codec<O, A>, right: Codec<P, B>): Codec<O & P, A & B>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const URI = "Codec";
+export declare function sum<T extends string>(tag: T): <M extends Record<string, Codec<any, any>>>(members: M) => Codec<OutputOf<M[keyof M]>, TypeOf<M[keyof M]>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
+export declare function lazy<O, A>(id: string, f: () => Codec<O, A>): Codec<O, A>;
+/**
+ * @since 2.2.3
+ */
+export declare const imap: <E, A, B>(f: (a: A) => B, g: (b: B) => A) => (fa: Codec<E, A>) => Codec<E, B>;
+/**
+ * @since 2.2.3
+ */
+export declare const URI = "io-ts/Codec";
+/**
+ * @since 2.2.3
+ */
 export declare type URI = typeof URI;
 declare module 'fp-ts/lib/HKT' {
-    interface URItoKind<A> {
-        readonly Codec: Codec<A>;
+    interface URItoKind2<E, A> {
+        readonly [URI]: Codec<E, A>;
     }
 }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const codec: Invariant1<URI> & Schemable<URI>;
+export declare const invariantCodec: Invariant2<URI>;

lib/Codec.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.invariantCodec = exports.URI = exports.imap = exports.lazy = exports.sum = exports.intersection = exports.tuple = exports.array = exports.record = exports.partial = exports.type = exports.nullable = exports.refinement = exports.withExpected = exports.UnknownRecord = exports.UnknownArray = exports.boolean = exports.number = exports.string = exports.literal = exports.fromDecoder = exports.make = void 0;
 var D = require("./Decoder");
 var E = require("./Encoder");
+var function_1 = require("fp-ts/lib/function");
 // -------------------------------------------------------------------------------------
@@ -9,3 +11,3 @@ // constructors
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -20,6 +22,15 @@ function make(decoder, encoder) {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
+function fromDecoder(decoder) {
+    return {
+        decode: decoder.decode,
+        encode: function_1.identity
+    };
+}
+exports.fromDecoder = fromDecoder;
+/**
+ * @since 2.2.3
+ */
 function literal() {
-    var _a, _b;
     var values = [];
@@ -29,3 +40,3 @@ for (var _i = 0; _i < arguments.length; _i++) {
     }
-    return make((_a = D.decoder).literal.apply(_a, values), (_b = E.encoder).literal.apply(_b, values));
+    return fromDecoder(D.literal.apply(D, values));
 }
@@ -37,21 +48,21 @@ exports.literal = literal;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-exports.string = make(D.decoder.string, E.encoder.string);
+exports.string = fromDecoder(D.string);
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-exports.number = make(D.decoder.number, E.encoder.number);
+exports.number = fromDecoder(D.number);
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-exports.boolean = make(D.decoder.boolean, E.encoder.boolean);
+exports.boolean = fromDecoder(D.boolean);
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-exports.UnknownArray = make(D.decoder.UnknownArray, E.encoder.UnknownArray);
+exports.UnknownArray = fromDecoder(D.UnknownArray);
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-exports.UnknownRecord = make(D.decoder.UnknownRecord, E.encoder.UnknownRecord);
+exports.UnknownRecord = fromDecoder(D.UnknownRecord);
 // -------------------------------------------------------------------------------------
@@ -61,3 +72,3 @@ // combinators
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -69,3 +80,3 @@ function withExpected(codec, expected) {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -77,41 +88,41 @@ function refinement(from, refinement, expected) {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 function nullable(or) {
-    return make(D.decoder.nullable(or), E.encoder.nullable(or));
+    return make(D.nullable(or), E.nullable(or));
 }
 exports.nullable = nullable;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 function type(properties) {
-    return make(D.decoder.type(properties), E.encoder.type(properties));
+    var decoder = D.type(properties);
+    return make(decoder, E.type(properties));
 }
 exports.type = type;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 function partial(properties) {
-    return make(D.decoder.partial(properties), E.encoder.partial(properties));
+    return make(D.partial(properties), E.partial(properties));
 }
 exports.partial = partial;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 function record(codomain) {
-    return make(D.decoder.record(codomain), E.encoder.record(codomain));
+    return make(D.record(codomain), E.record(codomain));
 }
 exports.record = record;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 function array(items) {
-    return make(D.decoder.array(items), E.encoder.array(items));
+    return make(D.array(items), E.array(items));
 }
 exports.array = array;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 function tuple() {
-    var _a, _b;
     var components = [];
@@ -121,18 +132,20 @@ for (var _i = 0; _i < arguments.length; _i++) {
     }
-    return make((_a = D.decoder).tuple.apply(_a, components), (_b = E.encoder).tuple.apply(_b, components));
+    var decoder = D.tuple.apply(D, components);
+    var encoder = E.tuple.apply(E, components);
+    return make(decoder, encoder);
 }
 exports.tuple = tuple;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 function intersection(left, right) {
-    return make(D.decoder.intersection(left, right), E.encoder.intersection(left, right));
+    return make(D.intersection(left, right), E.intersection(left, right));
 }
 exports.intersection = intersection;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 function sum(tag) {
-    var sumD = D.decoder.sum(tag);
-    var sumE = E.encoder.sum(tag);
+    var sumD = D.sum(tag);
+    var sumE = E.sum(tag);
     return function (members) { return make(sumD(members), sumE(members)); };
@@ -142,36 +155,33 @@ }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 function lazy(id, f) {
-    return make(D.decoder.lazy(id, f), E.encoder.lazy(id, f));
+    return make(D.lazy(id, f), E.lazy(f));
 }
 exports.lazy = lazy;
 // -------------------------------------------------------------------------------------
+// pipeables
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.2.3
+ */
+exports.imap = function (f, g) { return function (fa) {
+    return imap_(fa, f, g);
+}; };
+var imap_ = function (fa, f, g) {
+    return make(D.functorDecoder.map(fa, f), E.contravariantEncoder.contramap(fa, g));
+};
+// -------------------------------------------------------------------------------------
 // instances
 // -------------------------------------------------------------------------------------
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-exports.URI = 'Codec';
+exports.URI = 'io-ts/Codec';
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-exports.codec = {
+exports.invariantCodec = {
     URI: exports.URI,
-    imap: function (fa, f, g) { return make(D.decoder.map(fa, f), E.encoder.contramap(fa, g)); },
-    literal: literal,
-    string: exports.string,
-    number: exports.number,
-    boolean: exports.boolean,
-    UnknownArray: exports.UnknownArray,
-    UnknownRecord: exports.UnknownRecord,
-    nullable: nullable,
-    type: type,
-    partial: partial,
-    record: record,
-    array: array,
-    tuple: tuple,
-    intersection: intersection,
-    sum: sum,
-    lazy: lazy
+    imap: imap_
 };

lib/Decoder.d.ts

 /**
  * @since 2.2.0
  */
-import { Alternative1 } from 'fp-ts/lib/Alternative';
-import { Applicative1 } from 'fp-ts/lib/Applicative';
 import { Either } from 'fp-ts/lib/Either';
 import { NonEmptyArray } from 'fp-ts/lib/NonEmptyArray';
-import { Tree, Forest } from 'fp-ts/lib/Tree';
+import { Forest, Tree } from 'fp-ts/lib/Tree';
 import * as G from './Guard';
-import { Schemable, WithUnion, Literal } from './Schemable';
+import { Literal, Schemable1, WithRefinement1, WithUnion1, WithUnknownContainers1 } from './Schemable';
+import { Functor1 } from 'fp-ts/lib/Functor';
+import { Alt1 } from 'fp-ts/lib/Alt';
 /**
@@ -43,2 +43,6 @@ * @since 2.2.2
 /**
+ * @since 2.2.3
+ */
+export declare function of<A>(a: A): Decoder<A>;
+/**
  * @since 2.2.0
@@ -129,3 +133,3 @@ */
 export declare function sum<T extends string>(tag: T): <A>(members: {
-    [K in keyof A]: Decoder<A[K] & Record<T, K>>;
+    [K in keyof A]: Decoder<A[K]>;
 }) => Decoder<A[keyof A]>;
@@ -141,37 +145,31 @@ /**
  */
-export declare const URI = "Decoder";
+export declare const map: <A, B>(f: (a: A) => B) => (fa: Decoder<A>) => Decoder<B>;
 /**
  * @since 2.2.0
  */
-export declare type URI = typeof URI;
-declare module 'fp-ts/lib/HKT' {
-    interface URItoKind<A> {
-        readonly Decoder: Decoder<A>;
-    }
-}
+export declare const alt: <A>(that: () => Decoder<A>) => (fa: Decoder<A>) => Decoder<A>;
 /**
  * @since 2.2.0
  */
-export declare const decoder: Applicative1<URI> & Alternative1<URI> & Schemable<URI> & WithUnion<URI>;
-declare const alt: <A>(that: () => Decoder<A>) => (fa: Decoder<A>) => Decoder<A>, ap: <A>(fa: Decoder<A>) => <B>(fab: Decoder<(a: A) => B>) => Decoder<B>, apFirst: <B>(fb: Decoder<B>) => <A>(fa: Decoder<A>) => Decoder<A>, apSecond: <B>(fb: Decoder<B>) => <A>(fa: Decoder<A>) => Decoder<B>, map: <A, B>(f: (a: A) => B) => (fa: Decoder<A>) => Decoder<B>;
-export { 
+export declare const URI = "io-ts/Decoder";
 /**
  * @since 2.2.0
  */
-alt, 
+export declare type URI = typeof URI;
+declare module 'fp-ts/lib/HKT' {
+    interface URItoKind<A> {
+        readonly [URI]: Decoder<A>;
+    }
+}
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-ap, 
+export declare const functorDecoder: Functor1<URI>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-apFirst, 
+export declare const altDecoder: Alt1<URI>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-apSecond, 
-/**
- * @since 2.2.0
- */
-map };
+export declare const schemableDecoder: Schemable1<URI> & WithUnknownContainers1<URI> & WithUnion1<URI> & WithRefinement1<URI>;

lib/Decoder.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemableDecoder = exports.altDecoder = exports.functorDecoder = exports.URI = exports.alt = exports.map = exports.union = exports.sum = exports.lazy = exports.intersection = exports.intersect = exports.tuple = exports.array = exports.record = exports.partial = exports.type = exports.nullable = exports.parse = exports.refinement = exports.withExpected = exports.UnknownRecord = exports.UnknownArray = exports.boolean = exports.number = exports.string = exports.never = exports.literal = exports.fromGuard = exports.of = exports.isNotEmpty = exports.failure = exports.success = exports.tree = void 0;
+/**
+ * @since 2.2.0
+ */
 var Either_1 = require("fp-ts/lib/Either");
@@ -8,3 +12,3 @@ var pipeable_1 = require("fp-ts/lib/pipeable");
 // -------------------------------------------------------------------------------------
-// constructors
+// DecodeError
 // -------------------------------------------------------------------------------------
@@ -44,3 +48,15 @@ var empty = [];
 exports.isNotEmpty = isNotEmpty;
+// -------------------------------------------------------------------------------------
+// constructors
+// -------------------------------------------------------------------------------------
 /**
+ * @since 2.2.3
+ */
+function of(a) {
+    return {
+        decode: function () { return success(a); }
+    };
+}
+exports.of = of;
+/**
  * @since 2.2.0
@@ -67,3 +83,3 @@ */
     var expected = values.map(function (value) { return JSON.stringify(value); }).join(' | ');
-    return fromGuard((_a = G.guard).literal.apply(_a, values), expected);
+    return fromGuard((_a = G.schemableGuard).literal.apply(_a, values), expected);
 }
@@ -426,3 +442,3 @@ exports.literal = literal;
 // -------------------------------------------------------------------------------------
-// instances
+// pipeables
 // -------------------------------------------------------------------------------------
@@ -432,21 +448,46 @@ /**
  */
-exports.URI = 'Decoder';
+exports.map = function (f) { return function (fa) { return map_(fa, f); }; };
+var map_ = function (fa, f) { return ({
+    decode: function (u) {
+        var e = fa.decode(u);
+        return Either_1.isLeft(e) ? e : Either_1.right(f(e.right));
+    }
+}); };
 /**
  * @since 2.2.0
  */
-exports.decoder = {
+exports.alt = function (that) { return function (fa) { return alt_(fa, that); }; };
+var alt_ = function (fx, fy) { return ({
+    decode: function (u) {
+        var e = fx.decode(u);
+        return Either_1.isLeft(e) ? fy().decode(u) : e;
+    }
+}); };
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.2.0
+ */
+exports.URI = 'io-ts/Decoder';
+/**
+ * @since 2.2.3
+ */
+exports.functorDecoder = {
     URI: exports.URI,
-    map: function (fa, f) { return ({
-        decode: function (u) { return Either_1.either.map(fa.decode(u), f); }
-    }); },
-    of: function (a) { return ({
-        decode: function () { return success(a); }
-    }); },
-    ap: function (fab, fa) { return ({
-        decode: function (u) { return Either_1.either.ap(fab.decode(u), fa.decode(u)); }
-    }); },
-    alt: function (fx, fy) { return ({
-        decode: function (u) { return Either_1.either.alt(fx.decode(u), function () { return fy().decode(u); }); }
-    }); },
-    zero: function () { return exports.never; },
+    map: map_
+};
+/**
+ * @since 2.2.3
+ */
+exports.altDecoder = {
+    URI: exports.URI,
+    map: map_,
+    alt: alt_
+};
+/**
+ * @since 2.2.3
+ */
+exports.schemableDecoder = {
+    URI: exports.URI,
     literal: literal,
@@ -456,4 +497,2 @@ string: exports.string,
     boolean: exports.boolean,
-    UnknownArray: exports.UnknownArray,
-    UnknownRecord: exports.UnknownRecord,
     nullable: nullable,
@@ -468,9 +507,6 @@ type: type,
     lazy: lazy,
-    union: union
+    UnknownArray: exports.UnknownArray,
+    UnknownRecord: exports.UnknownRecord,
+    union: union,
+    refinement: refinement
 };
-var _a = pipeable_1.pipeable(exports.decoder), alt = _a.alt, ap = _a.ap, apFirst = _a.apFirst, apSecond = _a.apSecond, map = _a.map;
-exports.alt = alt;
-exports.ap = ap;
-exports.apFirst = apFirst;
-exports.apSecond = apSecond;
-exports.map = map;

lib/Encoder.d.ts

 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-import { Contravariant1 } from 'fp-ts/lib/Contravariant';
-import { Schemable } from './Schemable';
+import { Contravariant2 } from 'fp-ts/lib/Contravariant';
+import { Category2 } from 'fp-ts/lib/Category';
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export interface Encoder<A> {
-    readonly encode: (a: A) => unknown;
+export interface Encoder<O, A> {
+    readonly encode: (a: A) => O;
 }
 /**
- * @since 2.2.2
+ * @since 2.2.3
  */
-export declare type TypeOf<E> = E extends Encoder<infer A> ? A : never;
+export declare type TypeOf<E> = E extends Encoder<any, infer A> ? A : never;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const id: Encoder<unknown>;
+export declare type OutputOf<E> = E extends Encoder<infer O, any> ? O : never;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function nullable<A>(or: Encoder<A>): Encoder<null | A>;
+export declare function id<A>(): Encoder<A, A>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function type<A>(properties: {
-    [K in keyof A]: Encoder<A[K]>;
-}): Encoder<A>;
+export declare function nullable<O, A>(or: Encoder<O, A>): Encoder<null | O, null | A>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function partial<A>(properties: {
-    [K in keyof A]: Encoder<A[K]>;
-}): Encoder<Partial<A>>;
+export declare function type<P extends Record<string, Encoder<any, any>>>(properties: P): Encoder<{
+    [K in keyof P]: OutputOf<P[K]>;
+}, {
+    [K in keyof P]: TypeOf<P[K]>;
+}>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function record<A>(codomain: Encoder<A>): Encoder<Record<string, A>>;
+export declare function partial<P extends Record<string, Encoder<any, any>>>(properties: P): Encoder<Partial<{
+    [K in keyof P]: OutputOf<P[K]>;
+}>, Partial<{
+    [K in keyof P]: TypeOf<P[K]>;
+}>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function array<A>(items: Encoder<A>): Encoder<Array<A>>;
+export declare function record<O, A>(codomain: Encoder<O, A>): Encoder<Record<string, O>, Record<string, A>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function tuple<A extends ReadonlyArray<unknown>>(...components: {
-    [K in keyof A]: Encoder<A[K]>;
-}): Encoder<A>;
+export declare function array<O, A>(items: Encoder<O, A>): Encoder<Array<O>, Array<A>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function intersection<A, B>(left: Encoder<A>, right: Encoder<B>): Encoder<A & B>;
+export declare function tuple<C extends ReadonlyArray<Encoder<any, any>>>(...components: C): Encoder<{
+    [K in keyof C]: OutputOf<C[K]>;
+}, {
+    [K in keyof C]: TypeOf<C[K]>;
+}>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function sum<T extends string>(tag: T): <A>(members: {
-    [K in keyof A]: Encoder<A[K] & Record<T, K>>;
-}) => Encoder<A[keyof A]>;
+export declare function intersection<O, A, P, B>(left: Encoder<O, A>, right: Encoder<P, B>): Encoder<O & P, A & B>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare function lazy<A>(f: () => Encoder<A>): Encoder<A>;
+export declare function sum<T extends string>(tag: T): <M extends Record<string, Encoder<any, any>>>(members: M) => Encoder<OutputOf<M[keyof M]>, TypeOf<M[keyof M]>>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const URI = "Encoder";
+export declare function lazy<O, A>(f: () => Encoder<O, A>): Encoder<O, A>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
+export declare const contramap: <A, B>(f: (b: B) => A) => <E>(fa: Encoder<E, A>) => Encoder<E, B>;
+/**
+ * @since 2.2.3
+ */
+export declare const compose: <E, A>(ea: Encoder<E, A>) => <B>(ab: Encoder<A, B>) => Encoder<E, B>;
+/**
+ * @since 2.2.3
+ */
+export declare const URI = "io-ts/Encoder";
+/**
+ * @since 2.2.3
+ */
 export declare type URI = typeof URI;
 declare module 'fp-ts/lib/HKT' {
-    interface URItoKind<A> {
-        readonly Encoder: Encoder<A>;
+    interface URItoKind2<E, A> {
+        readonly [URI]: Encoder<E, A>;
     }
 }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const encoder: Contravariant1<URI> & Schemable<URI>;
-declare const contramap: <A, B>(f: (b: B) => A) => (fa: Encoder<A>) => Encoder<B>;
-export { 
+export declare const contravariantEncoder: Contravariant2<URI>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-contramap };
+export declare const categoryEncoder: Category2<URI>;

lib/Encoder.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.categoryEncoder = exports.contravariantEncoder = exports.URI = exports.compose = exports.contramap = exports.lazy = exports.sum = exports.intersection = exports.tuple = exports.array = exports.record = exports.partial = exports.type = exports.nullable = exports.id = void 0;
+var Decoder_1 = require("./Decoder");
+var Schemable_1 = require("./Schemable");
 var function_1 = require("fp-ts/lib/function");
-var pipeable_1 = require("fp-ts/lib/pipeable");
-var Schemable_1 = require("./Schemable");
-var Decoder_1 = require("./Decoder");
 // -------------------------------------------------------------------------------------
-// primitives
+// constructors
 // -------------------------------------------------------------------------------------
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-exports.id = {
-    encode: function_1.identity
-};
+function id() {
+    return {
+        encode: function_1.identity
+    };
+}
+exports.id = id;
 // -------------------------------------------------------------------------------------
@@ -20,7 +23,7 @@ // combinators
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
 function nullable(or) {
     return {
-        encode: function (a) { return (a === null ? a : or.encode(a)); }
+        encode: function (a) { return (a === null ? null : or.encode(a)); }
     };
@@ -30,3 +33,3 @@ }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -46,3 +49,3 @@ function type(properties) {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -58,3 +61,3 @@ function partial(properties) {
                     // don't strip undefined properties
-                    o[k] = v === undefined ? v : properties[k].encode(v);
+                    o[k] = v === undefined ? undefined : properties[k].encode(v);
                 }
@@ -68,3 +71,3 @@ }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -84,3 +87,3 @@ function record(codomain) {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -94,3 +97,3 @@ function array(items) {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -108,3 +111,3 @@ function tuple() {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -118,3 +121,3 @@ function intersection(left, right) {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -130,3 +133,3 @@ function sum(tag) {
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
@@ -141,33 +144,43 @@ function lazy(f) {
 // -------------------------------------------------------------------------------------
+// pipeables
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.2.3
+ */
+exports.contramap = function (f) { return function (fa) {
+    return contramap_(fa, f);
+}; };
+var contramap_ = function (fa, f) { return ({
+    encode: function (b) { return fa.encode(f(b)); }
+}); };
+/**
+ * @since 2.2.3
+ */
+exports.compose = function (ea) { return function (ab) {
+    return compose_(ab, ea);
+}; };
+var compose_ = function (ab, ea) { return ({
+    encode: function (b) { return ea.encode(ab.encode(b)); }
+}); };
+// -------------------------------------------------------------------------------------
 // instances
 // -------------------------------------------------------------------------------------
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-exports.URI = 'Encoder';
+exports.URI = 'io-ts/Encoder';
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-exports.encoder = {
+exports.contravariantEncoder = {
     URI: exports.URI,
-    contramap: function (fa, f) { return ({
-        encode: function (b) { return fa.encode(f(b)); }
-    }); },
-    literal: function () { return exports.id; },
-    string: exports.id,
-    number: exports.id,
-    boolean: exports.id,
-    UnknownArray: exports.id,
-    UnknownRecord: exports.id,
-    nullable: nullable,
-    type: type,
-    partial: partial,
-    record: record,
-    array: array,
-    tuple: tuple,
-    intersection: intersection,
-    sum: sum,
-    lazy: function (_, f) { return lazy(f); }
+    contramap: contramap_
 };
-var contramap = pipeable_1.pipeable(exports.encoder).contramap;
-exports.contramap = contramap;
+/**
+ * @since 2.2.3
+ */
+exports.categoryEncoder = {
+    URI: exports.URI,
+    compose: compose_,
+    id: id
+};

lib/Eq.d.ts

 import * as E from 'fp-ts/lib/Eq';
-import * as S from './Schemable';
+import { Schemable1, WithRefinement1, WithUnknownContainers1 } from './Schemable';
 import Eq = E.Eq;
 /**
+ * @since 2.2.3
+ */
+export declare type URI = E.URI;
+/**
  * @since 2.2.2
@@ -66,3 +70,3 @@ */
 export declare function sum<T extends string>(tag: T): <A>(members: {
-    [K in keyof A]: Eq<A[K] & Record<T, K>>;
+    [K in keyof A]: Eq<A[K]>;
 }) => Eq<A[keyof A]>;
@@ -74,4 +78,4 @@ /**
 /**
- * @since 2.2.2
+ * @since 2.2.3
  */
-export declare const eq: typeof E.eq & S.Schemable<E.URI>;
+export declare const schemableEq: Schemable1<E.URI> & WithUnknownContainers1<E.URI> & WithRefinement1<E.URI>;

lib/Eq.js

 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemableEq = exports.lazy = exports.sum = exports.intersection = exports.tuple = exports.array = exports.record = exports.partial = exports.type = exports.nullable = exports.UnknownRecord = exports.UnknownArray = exports.boolean = exports.number = exports.string = void 0;
 /**
@@ -20,3 +10,3 @@ * @since 2.2.2
 var R = require("fp-ts/lib/Record");
-var S = require("./Schemable");
+var Schemable_1 = require("./Schemable");
 // -------------------------------------------------------------------------------------
@@ -134,3 +124,3 @@ // primitives
 function lazy(f) {
-    var get = S.memoize(f);
+    var get = Schemable_1.memoize(f);
     return {
@@ -141,10 +131,14 @@ equals: function (x, y) { return get().equals(x, y); }
 exports.lazy = lazy;
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
 /**
- * @since 2.2.2
+ * @since 2.2.3
  */
-exports.eq = __assign(__assign({}, E.eq), { literal: function () { return E.eqStrict; }, string: exports.string,
+exports.schemableEq = {
+    URI: E.URI,
+    literal: function () { return E.eqStrict; },
+    string: exports.string,
     number: exports.number,
     boolean: exports.boolean,
-    UnknownArray: exports.UnknownArray,
-    UnknownRecord: exports.UnknownRecord,
     nullable: nullable,
@@ -157,2 +151,7 @@ type: exports.type,
     intersection: intersection,
-    sum: sum, lazy: function (_, f) { return lazy(f); } });
+    sum: sum,
+    lazy: function (_, f) { return lazy(f); },
+    UnknownArray: exports.UnknownArray,
+    UnknownRecord: exports.UnknownRecord,
+    refinement: function (from) { return from; }
+};

lib/Guard.d.ts

 /**
  * @since 2.2.0
  */
-import { Schemable, WithUnion, Literal } from './Schemable';
+import { Literal, Schemable1, WithRefinement1, WithUnion1, WithUnknownContainers1 } from './Schemable';
 /**
@@ -91,3 +91,3 @@ * @since 2.2.0
 export declare function sum<T extends string>(tag: T): <A>(members: {
-    [K in keyof A]: Guard<A[K] & Record<T, K>>;
+    [K in keyof A]: Guard<A[K]>;
 }) => Guard<A[keyof A]>;
@@ -101,3 +101,3 @@ /**
  */
-export declare const URI = "Guard";
+export declare const URI = "io-ts/Guard";
 /**
@@ -109,8 +109,8 @@ * @since 2.2.0
     interface URItoKind<A> {
-        readonly Guard: Guard<A>;
+        readonly [URI]: Guard<A>;
     }
 }
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export declare const guard: Schemable<URI> & WithUnion<URI>;
+export declare const schemableGuard: Schemable1<URI> & WithUnknownContainers1<URI> & WithUnion1<URI> & WithRefinement1<URI>;

lib/Guard.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemableGuard = exports.URI = exports.lazy = exports.sum = exports.union = exports.intersection = exports.tuple = exports.array = exports.record = exports.partial = exports.type = exports.nullable = exports.refinement = exports.UnknownRecord = exports.UnknownArray = exports.boolean = exports.number = exports.string = exports.never = exports.literal = void 0;
 /**
@@ -199,7 +200,7 @@ * @since 2.2.0
  */
-exports.URI = 'Guard';
+exports.URI = 'io-ts/Guard';
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-exports.guard = {
+exports.schemableGuard = {
     URI: exports.URI,
@@ -210,4 +211,2 @@ literal: literal,
     boolean: exports.boolean,
-    UnknownArray: exports.UnknownArray,
-    UnknownRecord: exports.UnknownRecord,
     nullable: nullable,
@@ -222,3 +221,6 @@ type: type,
     lazy: function (_, f) { return lazy(f); },
-    union: union
+    UnknownArray: exports.UnknownArray,
+    UnknownRecord: exports.UnknownRecord,
+    union: union,
+    refinement: refinement
 };

lib/index.d.ts

@@ -753,7 +753,3 @@ /**
  */
-export interface ReadonlyC<C extends Mixed> extends ReadonlyType<C, {
-    readonly [K in keyof TypeOf<C>]: TypeOf<C>[K];
-}, {
-    readonly [K in keyof OutputOf<C>]: OutputOf<C>[K];
-}, unknown> {
+export interface ReadonlyC<C extends Mixed> extends ReadonlyType<C, Readonly<TypeOf<C>>, Readonly<OutputOf<C>>, unknown> {
 }
@@ -760,0 +756,0 @@ /**

lib/index.js

@@ -34,2 +34,3 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIndex = exports.getTags = exports.emptyTags = exports.alias = exports.clean = exports.StrictType = exports.dictionary = exports.Integer = exports.refinement = exports.object = exports.ObjectType = exports.Dictionary = exports.any = exports.AnyType = exports.never = exports.NeverType = exports.getDefaultContext = exports.getValidationError = exports.void = exports.interface = exports.Array = exports.undefined = exports.null = exports.exact = exports.ExactType = exports.taggedUnion = exports.TaggedUnionType = exports.strict = exports.readonlyArray = exports.ReadonlyArrayType = exports.readonly = exports.ReadonlyType = exports.tuple = exports.TupleType = exports.intersection = exports.IntersectionType = exports.union = exports.UnionType = exports.record = exports.getDomainKeys = exports.DictionaryType = exports.partial = exports.PartialType = exports.type = exports.InterfaceType = exports.array = exports.ArrayType = exports.recursion = exports.RecursiveType = exports.keyof = exports.KeyofType = exports.literal = exports.LiteralType = exports.Int = exports.brand = exports.RefinementType = exports.Function = exports.FunctionType = exports.UnknownRecord = exports.AnyDictionaryType = exports.UnknownArray = exports.AnyArrayType = exports.boolean = exports.BooleanType = exports.bigint = exports.BigIntType = exports.number = exports.NumberType = exports.string = exports.StringType = exports.unknown = exports.UnknownType = exports.voidType = exports.VoidType = exports.UndefinedType = exports.nullType = exports.NullType = exports.success = exports.failure = exports.failures = exports.appendContext = exports.getContextEntry = exports.getFunctionName = exports.identity = exports.Type = void 0;
 /**
@@ -36,0 +37,0 @@ * @since 1.0.0

lib/PathReporter.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathReporter = exports.success = exports.failure = void 0;
 var _1 = require(".");
@@ -4,0 +5,0 @@ var Either_1 = require("fp-ts/lib/Either");

lib/Schema.d.ts

 /**
  * @since 2.2.0
  */
-import { Kind, URIS } from 'fp-ts/lib/HKT';
-import { Schemable } from './Schemable';
+import { HKT, URIS, Kind } from 'fp-ts/lib/HKT';
+import { Schemable, Schemable1 } from './Schemable';
 /**
@@ -10,3 +10,3 @@ * @since 2.2.0
 export interface Schema<A> {
-    <S extends URIS>(S: Schemable<S>): Kind<S, A>;
+    <S>(S: Schemable<S>): HKT<S, A>;
 }
@@ -20,2 +20,6 @@ /**
  */
-export declare function make<A>(f: Schema<A>): Schema<A>;
+export declare function make<A>(schema: Schema<A>): Schema<A>;
+/**
+ * @since 2.2.3
+ */
+export declare function interpreter<S extends URIS>(S: Schemable1<S>): <A>(schema: Schema<A>) => Kind<S, A>;

lib/Schema.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpreter = exports.make = void 0;
 var Schemable_1 = require("./Schemable");
@@ -7,5 +8,12 @@ /**
  */
-function make(f) {
-    return Schemable_1.memoize(f);
+function make(schema) {
+    return Schemable_1.memoize(schema);
 }
 exports.make = make;
+/**
+ * @since 2.2.3
+ */
+function interpreter(S) {
+    return function (schema) { return schema(S); };
+}
+exports.interpreter = interpreter;

lib/Schemable.d.ts

 /**
  * @since 2.2.0
  */
-import { Kind, URIS } from 'fp-ts/lib/HKT';
+import { Kind, URIS, HKT } from 'fp-ts/lib/HKT';
 /**
@@ -10,6 +10,33 @@ * @since 2.2.0
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export interface Schemable<S extends URIS> {
+export interface Schemable<S> {
     readonly URI: S;
+    readonly literal: <A extends ReadonlyArray<Literal>>(...values: A) => HKT<S, A[number]>;
+    readonly string: HKT<S, string>;
+    readonly number: HKT<S, number>;
+    readonly boolean: HKT<S, boolean>;
+    readonly nullable: <A>(or: HKT<S, A>) => HKT<S, null | A>;
+    readonly type: <A>(properties: {
+        [K in keyof A]: HKT<S, A[K]>;
+    }) => HKT<S, A>;
+    readonly partial: <A>(properties: {
+        [K in keyof A]: HKT<S, A[K]>;
+    }) => HKT<S, Partial<A>>;
+    readonly record: <A>(codomain: HKT<S, A>) => HKT<S, Record<string, A>>;
+    readonly array: <A>(items: HKT<S, A>) => HKT<S, Array<A>>;
+    readonly tuple: <A extends ReadonlyArray<unknown>>(...components: {
+        [K in keyof A]: HKT<S, A[K]>;
+    }) => HKT<S, A>;
+    readonly intersection: <A, B>(left: HKT<S, A>, right: HKT<S, B>) => HKT<S, A & B>;
+    readonly sum: <T extends string>(tag: T) => <A>(members: {
+        [K in keyof A]: HKT<S, A[K]>;
+    }) => HKT<S, A[keyof A]>;
+    readonly lazy: <A>(id: string, f: () => HKT<S, A>) => HKT<S, A>;
+}
+/**
+ * @since 2.2.3
+ */
+export interface Schemable1<S extends URIS> {
+    readonly URI: S;
     readonly literal: <A extends ReadonlyArray<Literal>>(...values: A) => Kind<S, A[number]>;
@@ -19,4 +46,2 @@ readonly string: Kind<S, string>;
     readonly boolean: Kind<S, boolean>;
-    readonly UnknownArray: Kind<S, Array<unknown>>;
-    readonly UnknownRecord: Kind<S, Record<string, unknown>>;
     readonly nullable: <A>(or: Kind<S, A>) => Kind<S, null | A>;
@@ -36,3 +61,3 @@ readonly type: <A>(properties: {
     readonly sum: <T extends string>(tag: T) => <A>(members: {
-        [K in keyof A]: Kind<S, A[K] & Record<T, K>>;
+        [K in keyof A]: Kind<S, A[K]>;
     }) => Kind<S, A[keyof A]>;
@@ -42,6 +67,28 @@ readonly lazy: <A>(id: string, f: () => Kind<S, A>) => Kind<S, A>;
 /**
- * @since 2.2.0
+ * @since 2.2.3
  */
-export interface WithUnion<S extends URIS> {
+export interface WithUnknownContainers<S> {
+    readonly UnknownArray: HKT<S, Array<unknown>>;
+    readonly UnknownRecord: HKT<S, Record<string, unknown>>;
+}
+/**
+ * @since 2.2.3
+ */
+export interface WithUnknownContainers1<S extends URIS> {
+    readonly UnknownArray: Kind<S, Array<unknown>>;
+    readonly UnknownRecord: Kind<S, Record<string, unknown>>;
+}
+/**
+ * @since 2.2.3
+ */
+export interface WithUnion<S> {
     readonly union: <A extends ReadonlyArray<unknown>>(...members: {
+        [K in keyof A]: HKT<S, A[K]>;
+    }) => HKT<S, A[number]>;
+}
+/**
+ * @since 2.2.3
+ */
+export interface WithUnion1<S extends URIS> {
+    readonly union: <A extends ReadonlyArray<unknown>>(...members: {
         [K in keyof A]: Kind<S, A[K]>;
@@ -51,4 +98,16 @@ }) => Kind<S, A[number]>;
 /**
+ * @since 2.2.3
+ */
+export interface WithRefinement<S> {
+    readonly refinement: <A, B extends A>(from: HKT<S, A>, refinement: (a: A) => a is B, expected: string) => HKT<S, B>;
+}
+/**
+ * @since 2.2.3
+ */
+export interface WithRefinement1<S extends URIS> {
+    readonly refinement: <A, B extends A>(from: Kind<S, A>, refinement: (a: A) => a is B, expected: string) => Kind<S, B>;
+}
+/**
  * @since 2.2.0
  */
 export declare function memoize<A, B>(f: (a: A) => B): (a: A) => B;

lib/Schemable.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoize = void 0;
 /**
@@ -4,0 +5,0 @@ * @since 2.2.0

lib/ThrowReporter.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThrowReporter = void 0;
 var PathReporter_1 = require("./PathReporter");
@@ -4,0 +5,0 @@ var Either_1 = require("fp-ts/lib/Either");

lib/Tree.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.draw = void 0;
 /**
@@ -4,0 +5,0 @@ * @since 2.2.0

package.json

 {
   "name": "io-ts",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "description": "TypeScript runtime type system for IO decoding/encoding",
@@ -25,3 +25,3 @@ "files": [
     "mocha": "TS_NODE_CACHE=false mocha -r ts-node/register test/*.ts",
-    "doctoc": "doctoc README.md Type.md Decoder.md Encoder.md Codec.md Eq.md",
+    "doctoc": "doctoc README.md Type.md Decoder.md Encoder.md Codec.md Eq.md Schema.md",
     "docs": "docs-ts",
@@ -63,3 +63,3 @@ "import-path-rewrite": "import-path-rewrite"
     "tslint-config-standard": "9.0.0",
-    "typescript": "3.8.3"
+    "typescript": "^3.9.3"
   },
@@ -66,0 +66,0 @@ "tags": [

README.md

 [![build status](https://img.shields.io/travis/gcanti/io-ts/master.svg?style=flat-square)](https://travis-ci.org/gcanti/io-ts)
 [![dependency status](https://img.shields.io/david/gcanti/io-ts.svg?style=flat-square)](https://david-dm.org/gcanti/io-ts)
 ![npm downloads](https://img.shields.io/npm/dm/io-ts.svg)
-[![Minified Size](https://badgen.net/bundlephobia/minzip/io-ts)](https://bundlephobia.com/result?p=io-ts)
 
@@ -10,4 +9,5 @@ <!-- START doctoc generated TOC please keep comment here to allow auto update -->
 - [Installation](#installation)
-- [Documentation](#documentation)
-  - [Usage](#usage)
+- [Usage](#usage)
+  - [Stable features](#stable-features)
+  - [Experimental features (version `2.2+`)](#experimental-features-version-22)
 
@@ -18,3 +18,3 @@ <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
-To install the stable version:
+To install the stable version
 
@@ -25,22 +25,18 @@ ```sh
 
-Note: [`fp-ts`](https://github.com/gcanti/fp-ts) is a peer dependency for `io-ts`
+**Note**. [`fp-ts`](https://github.com/gcanti/fp-ts) is a peer dependency for `io-ts`
 
-# Documentation
+# Usage
 
-- [API Reference](https://gcanti.github.io/io-ts/docs/modules)
+## Stable features
 
-## Usage
+- [`index.ts` module](index.md)
 
-**Stable features**
+## Experimental features (version `2.2+`)
 
-- [`Type`](Type.md)
-
-**Experimental features** (version `2.2+`)
-
 Experimental features are published in order to get early feedback from the community, see these tracking [issues](https://github.com/gcanti/io-ts/issues?q=label%3Av2.2+) for further discussions and enhancements.
 
-- [`Decoder`](Decoder.md)
-- [`Encoder`](Encoder.md)
-- [`Codec`](Codec.md)
-- [`Eq`](Eq.md)
-- [`Schema` (advanced feature)](Schema.md)
+- [`Decoder.ts` module](Decoder.md)
+- [`Encoder.ts` module](Encoder.md)
+- [`Codec.ts` module](Codec.md)
+- [`Eq.ts` module](Eq.md)
+- [`Schema.ts` module (advanced feature)](Schema.md)

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

315411

increased by17.21%

Number of package files

64

increased by23.08%

Lines of code

10883

increased by18.33%

Worsened metrics

Number of lines in readme file

40

decreased by-9.09%

No dependency changes