The idea

A value of type Type (called "runtime type") is a representation of the type T:

``js
class Type {
name: string;
validate: (value: mixed, context: Context) => Validation;
}
`

where Context and Validation are defined as

`js
type ContextEntry = { key: string, name: string };
type Context = Array;
type ValidationError = { value: mixed, context: Context, description: string };
type Validation = Either, T>;
`

Example: a runtime type representing the type string is

`js
import * as t from 'flow-io'

export const string: Type = new Type(
'string',
(v, c) => typeof v === 'string' ? t.success(v) : t.failure(v, c)
)
`

A runtime type can be used to validate an object in memory (for example an API payload)

`js
import * as t from 'flow-io'

const Person = t.object({
name: t.string,
age: t.number
})

// ok
t.fromValidation(JSON.parse('{"name":"Giulio","age":43}'), Person) // => {name: "Giulio", age: 43}

// throws Invalid value undefined supplied to : { name: string, age: number }/age: number
t.fromValidation(JSON.parse('{"name":"Giulio"}'), Person)

// doesn't throw, returns an Either
const validation = t.validate(JSON.parse('{"name":"Giulio"}'), Person)
t.map(person => console.log(person), validation)
`

Runtime type introspection

Runtime types can be inspected

`js
const Name: Type = Person.props.name
const Age: Type = Person.props.age
`

Error reporters

A reporter implements the following interface

`js
export interface Reporter {
report: (validation: Validation<*>) => A;
}
`

This package exports two default reporters

- PathReporter: Reporter>
- ThrowReporter: Reporter

Example

`js
import * as t from 'flow-io'
import { PathReporter, ThrowReporter } from 'flow-io/lib/reporters/default'

const validation = t.validate('a', t.number)
console.log(PathReporter.report(validation)) // => ["Invalid value "a" supplied to : number"]
ThrowReporter.report(validation) // => throws Invalid value "a" supplied to : number
`

Implemented types / combinators

| Type | Flow syntax | Runtime type / combinator |
|------|-------|-------------|
| string | string | string |
| number | number | number |
| boolean | boolean | boolean |
| generic object | Object | Object |
| generic function | Function | Function |
| instance of C | C | instanceOf(C) |
| class of C | Class | classOf(C) |
| array | Array | array(A) |
| intersection | A & B | intersection([A, B]) |
| literal | 's' | literal('s') |
| maybe | ?A | maybe(A) |
| map | { [key: A]: B } | mapping(A, B) |
| refinement | ✘ | refinement(A, predicate) |
| object | { name: string } | object({ name: string }) |
| tuple | [A, B] | tuple([A, B]) |
| union | A | B | union([A, B]) |
| $Exact | {| name: string |} | $exact({ name: string }) |
| function | (a: A) => B` | ✘ |