```typescript
const schema =
pipe(toNumber, lift(x => x + 1))

result('123', schema)
// 124
```

### `apply`

Set the input of a schema to a fixed value. Can be used when creating
a schema where the definition of one key depends on another.

```typescript
type Schedule = {
weekday : string
price : number
}

const schema = self((schedule : Schedule) => object({
weekday: oneOf('Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'),
price: when(
// When schedule.weekday is Sat or Sun, the
// price must be at least 100, otherwise at most 50.
apply(oneOf('Sat', 'Sun'), schedule.weekday, 'weekday'),
atLeast(100),
atMost(50)
)
})
```

### `every`

A variable arguments version of `both`.

### `setMessage`

Set the error message of a parser.

```typescript
const thing = setMessage(
object({ foo: string, bar: number }),
l => l.noun('should be a thingy),
)

check({ foo: '' } as any, thing, enUS)
// 'Should be a thingy'
```

### `some`

A variable arguments version of `either`.

### `when`

"if-then-else" on parsers.

The "else" part is optional, in which case this combinator has the signature

```typescript
const schema =
when(even, atLeast(10), atMost(20))

check(8, schema, enUS)
// 'Must be at least 10 when even'

check(21, schema, enUS)
// 'Must be at most 20 when not even'

check(11, schema, enUS)
// null
```

## Basic schemas

Matches a value at least as big as the provided lower bound `lb`.

```typescript
const schema =
atLeast(100)

check(88, schema, enUS)
// 'Must be at least 100'
```

### `atMost`

Matches a value at most as big as the provided upper bound `ub`.

```typescript
const schema =
atMost(100)

check(88, schema, enUS)
// 'Must be at most 100'
```

### `between`

Matches a value between the provided lower and upper bounds (inclusive)

```java
between :: (lb : number, ub : number) => Schema_
```

```typescript
check(99, schema, enUS)
// 'Must be between 100 and 200'

check(201, schema, enUS)
// 'Must be between 100 and 200'

check(100, schema, enUS)
// null

check(200, schema, enUS)
// null
```

### `boolean`

Matches a boolean.

```java
boolean :: Schema_
```

### `date`

Matches a `Date` object.

```java
date :: Schema_
```

### `email`

Matches an email (validated using a permissive regular expression)

```java
email :: Schema_
```

### `emptyString`

Matches the empty string

```java
emptyString :: Schema_
```

### `even`

Matches an even number

```java
even :: Schema_
```

### `exactly`

Creates a schema that matches a single value, optionally using an equality comparison operator.

```typescript
check('abc', exactly('abc'), enUS)
// null

check('abd', exactly('abc'), enUS)
// 'Must be abc'

check('abd', exactly('abc', (x, y) => x.length === y.length), enUS)
// null
```

### `id`

The identity schema that always succeeds. Unlike `any`, `id` can be provided a type
argument other than the `any` type.

```typescript
const schema =
object({ foo: id() })

check({ foo: 123 }, schema, enUS)
// null

check({ foo: 'hi!' }, schema, enUS)
// evaluates to null, but has a type error
```

### `integer`

Match a whole number

```java
integer :: Schema_
```

### `length`

Match an object with property length matching the schema argument

```typescript
const username =
string(length(exactly(10)))

const items =
array(between(1, 10))
```

### `lessThan`

Match a number less than the provided upper bound `ub`

```java
lessThan :: (ub : number) => Schema_
```

### `lift`

Lift a function into a schema that uses the function for parsing.

```typescript
const schema =
pipe(toNumber, lift(x => x + 1))

result('123', schema)
// 124
```

### `match`

Match a string matching the provided regular expression.

```typescript
const greeting =
match(/Hello|Hi|Hola/, m => m.mustBe('a greeting'))

check('Hello', greeting, enUS)
// null

check('Yo', greeting, enUS)
// 'Must be a greeting'
```

### `moreThan`

Match a number more than the provided lower bound `lb`

```java
moreThan :: (lb : number) => Schema_
```

### `number`

Match any number

```java
number :: Schema_
```

### `objectExact`

Like `object` but match the object exactly, i.e. error if additional
keys to the ones specified are present.

### `objectInexact`

Like `object` but match the object inexactly, i.e. whereas `object`
will silently remove any keys not specified in the schema,
`objectInexact` will keep them.

### `odd`

Matches an odd number

```java
odd :: Schema_
```

### `oneOf`

Match exactly one of the given elements

```typescript
const weekend =
oneOf('Fri', 'Sat', 'Sun'),

check('Sat', weekend, enUS)
// null

check('Wed', weekend, enUS)
// Must be Fri, Sat or Sun
```

### `swap`

Swap elements

```typescript
const optionalToEmptyString =
swap([[undefined, ''], [null, '']])

result(null, optionalToEmptyString)
// ''

result(undefined, optionalToEmptyString)
// ''

result('foo', optionalToEmptyString)
// 'foo'
```

### `optionalTo`

Map `null` and `undefined` to another value.

```typescript
const schema =
pipe(optionalTo(''), length(atMost(3)))

result(null, schema)
// ''

check(null, schema, enUS)
// null'

check('123123', schema, enUS)
// 'Must have length at most 3.'
```

### `pair`

Create a schema for pairs or values from a pair of schemas (where a
pair is a typed two-element array)