remove maybe combinator

README.md

@@ -62,7 +62,7 @@ This package exports two default reporters
 Example
 
 ```js
-import { PathReporter, ThrowReporter } from '../src/reporters/default'
+import { PathReporter, ThrowReporter } from 'io-ts/reporters/default'
 
 const validation = t.validate({"name":"Giulio"}, Person)
 
@@ -146,6 +146,26 @@ import * as t from 'io-ts'
 | keyof | `keyof M` | `t.keyof(M)` |
 | recursive types | | `t.recursion(name, definition)` |
 
+# Custom combinators
+
+You can define your own combinators. Let's see some interesting examples
+
+## The `maybe` combinator
+
+```ts
+export function maybe<RT extends t.Any>(type: RT, name?: string): t.UnionType<[RT, typeof t.null], t.TypeOf<RT> | null> {
+ return t.union([type, t.null], name)
+}
+```
+
+## The `brand` combinator
+
+```ts
+export function brand<T, B extends string>(type: t.Type<T>, brand: B): t.Type<T & { readonly __brand: B }> {
+ return type as any
+}
+```
+
 # Known issues
 
 Due to an upstream [bug](https://github.com/Microsoft/TypeScript/issues/14041), VS Code might display weird types for nested interfaces

src/index.ts

@@ -188,24 +188,6 @@ export function recursion<T>(name: string, definition: (self: Any) => Any): Type
  return Result
 }
 
-//
-// maybes
-//
-
-export class MaybeType<RT extends Any> extends Type<TypeOf<RT> | null> {
- constructor(name: string, validate: Validate<TypeOf<RT> | null>, public readonly type: RT) {
- super(name, validate)
- }
-}
-
-export function maybe<RT extends Any>(type: RT, name?: string): MaybeType<RT> {
- return new MaybeType(
- name || `(${getTypeName(type)} | null)`,
- (v, c) => v === null ? success(v) : type.validate(v, c),
- type
- )
-}
-
 //
 // arrays
 //

test/recursion.ts

@@ -10,7 +10,7 @@ describe('recursion', () => {
  it('should succeed validating a valid value', () => {
  const T = t.recursion('T', self => t.interface({
  a: t.number,
- b: t.maybe(self)
+ b: t.union([self, t.undefined, t.null])
  }))
  assertSuccess(t.validate({ a: 1, b: null }, T))
  assertSuccess(t.validate({ a: 1, b: { a: 2, b: null } }, T))
@@ -19,7 +19,7 @@ describe('recursion', () => {
  it('should return the same reference if validation succeeded', () => {
  const T = t.recursion('T', self => t.interface({
  a: t.number,
- b: t.maybe(self)
+ b: t.union([self, t.undefined, t.null])
  }))
  const value = { a: 1, b: { a: 2, b: null } }
  assertStrictEqual(t.validate(value, T), value)
@@ -28,18 +28,16 @@ describe('recursion', () => {
  it('should fail validating an invalid value', () => {
  const T = t.recursion('T', self => t.interface({
  a: t.number,
- b: t.maybe(self)
+ b: t.union([self, t.undefined, t.null])
  }))
  assertFailure(t.validate(1, T), [
  'Invalid value 1 supplied to : T'
  ])
  assertFailure(t.validate({}, T), [
- 'Invalid value undefined supplied to : T/a: number',
- 'Invalid value undefined supplied to : T/b: (T | null)'
+ 'Invalid value undefined supplied to : T/a: number'
  ])
  assertFailure(t.validate({ a: 1, b: {} }, T), [
- 'Invalid value undefined supplied to : T/b: (T | null)/a: number',
- 'Invalid value undefined supplied to : T/b: (T | null)/b: (T | null)'
+ 'Invalid value {} supplied to : T/b: (T | undefined | null)'
  ])
  })
 

typings-checker/index.ts

@@ -45,18 +45,6 @@ const R1 = t.refinement(t.number, n => n % 2 === 0)
 ;('s' as TypeOf<typeof R1>)
 ;(2 as TypeOf<typeof R1>)
 
-//
-// maybes
-//
-
-const M1 = t.maybe(t.number)
-// $ExpectError Type 'string' cannot be converted to type 'number | null'
-;('s' as TypeOf<typeof M1>)
-// $ExpectError Type 'undefined' cannot be converted to type 'number | null'
-;(undefined as TypeOf<typeof M1>)
-;(2 as TypeOf<typeof M1>)
-;(null as TypeOf<typeof M1>)
-
 //
 // arrays
 //