@typed/fp
Version:
Data Structures and Resources for fp-ts
916 lines (608 loc) • 14.2 kB
Markdown
---
title: Decoder.ts
nav_order: 10
parent: Modules
---
## Decoder overview
Decoder is a data structure for representing runtime representations of your types.
Added in v0.9.4
---
<h2 class="text-delta">Table of contents</h2>
- [Combinator](#combinator)
- [absolve](#absolve)
- [absolveWhen](#absolvewhen)
- [ap](#ap)
- [apFirst](#apfirst)
- [apS](#aps)
- [apSecond](#apsecond)
- [apT](#apt)
- [bind](#bind)
- [bindTo](#bindto)
- [chain](#chain)
- [chainFirst](#chainfirst)
- [compose](#compose)
- [condemmMissingKeys](#condemmmissingkeys)
- [condemn](#condemn)
- [condemnUnexpectedKeys](#condemnunexpectedkeys)
- [condemnWhen](#condemnwhen)
- [flap](#flap)
- [getApplicativeMonoid](#getapplicativemonoid)
- [intersect](#intersect)
- [map](#map)
- [nullable](#nullable)
- [optional](#optional)
- [refine](#refine)
- [strict](#strict)
- [tupled](#tupled)
- [Constructor](#constructor)
- [Chain](#chain)
- [Do](#do)
- [array](#array)
- [boolean](#boolean)
- [date](#date)
- [fromArray](#fromarray)
- [fromIO](#fromio)
- [fromRecord](#fromrecord)
- [fromRefinement](#fromrefinement)
- [fromStruct](#fromstruct)
- [fromTuple](#fromtuple)
- [lazy](#lazy)
- [literal](#literal)
- [missingIndexes](#missingindexes)
- [missingKeys](#missingkeys)
- [number](#number)
- [of](#of)
- [record](#record)
- [string](#string)
- [struct](#struct)
- [sum](#sum)
- [tuple](#tuple)
- [unexpectedIndexes](#unexpectedindexes)
- [unexpectedKeys](#unexpectedkeys)
- [union](#union)
- [unknownArray](#unknownarray)
- [unknownRecord](#unknownrecord)
- [Decoder](#decoder)
- [dateFromISOString](#datefromisostring)
- [jsonParse](#jsonparse)
- [jsonParseFromString](#jsonparsefromstring)
- [Instance](#instance)
- [Applicative](#applicative)
- [Apply](#apply)
- [Functor](#functor)
- [Monad](#monad)
- [Pointed](#pointed)
- [Schemable](#schemable)
- [WithRefine](#withrefine)
- [WithUnion](#withunion)
- [Interpreter](#interpreter)
- [assert](#assert)
- [assertStrict](#assertstrict)
- [Model](#model)
- [Decoder (interface)](#decoder-interface)
- [Refinement](#refinement)
- [isDate](#isdate)
- [Type-level](#type-level)
- [InputOf (type alias)](#inputof-type-alias)
- [OutputOf (type alias)](#outputof-type-alias)
- [Typeclass Constructor](#typeclass-constructor)
- [getApplySemigroup](#getapplysemigroup)
- [URI](#uri)
- [URI](#uri-1)
- [URI (type alias)](#uri-type-alias)
---
# Combinator
## absolve
**Signature**
```ts
export declare const absolve: <I, A>(decoder: Decoder<I, A>) => Decoder<I, A>
```
Added in v0.9.4
## absolveWhen
**Signature**
```ts
export declare function absolveWhen(predicate: Predicate<DE.DecodeError>)
```
Added in v0.9.4
## ap
**Signature**
```ts
export declare const ap: <E, A>(
fa: Decoder<E, A>,
) => <B>(fab: Decoder<E, (a: A) => B>) => Decoder<E, B>
```
Added in v0.9.4
## apFirst
**Signature**
```ts
export declare const apFirst: <E, B>(
second: Decoder<E, B>,
) => <A>(first: Decoder<E, A>) => Decoder<E, A>
```
Added in v0.9.4
## apS
**Signature**
```ts
export declare const apS: <N, A, E, B>(
name: Exclude<N, keyof A>,
fb: Decoder<E, B>,
) => (
fa: Decoder<E, A>,
) => Decoder<E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }>
```
Added in v0.9.4
## apSecond
**Signature**
```ts
export declare const apSecond: <E, B>(
second: Decoder<E, B>,
) => <A>(first: Decoder<E, A>) => Decoder<E, B>
```
Added in v0.9.4
## apT
**Signature**
```ts
export declare const apT: <E, B>(
fb: Decoder<E, B>,
) => <A>(fas: Decoder<E, A>) => Decoder<E, readonly [...A, B]>
```
Added in v0.9.4
## bind
**Signature**
```ts
export declare const bind: <N, A, E, B>(
name: Exclude<N, keyof A>,
f: (a: A) => Decoder<E, B>,
) => (
ma: Decoder<E, A>,
) => Decoder<E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }>
```
Added in v0.9.4
## bindTo
**Signature**
```ts
export declare const bindTo: <N>(
name: N,
) => <E, A>(fa: Decoder<E, A>) => Decoder<E, { readonly [K in N]: A }>
```
Added in v0.9.4
## chain
**Signature**
```ts
export declare const chain: <A, I, B>(
f: (a: A) => Decoder<I, B>,
) => (decoder: Decoder<I, A>) => Decoder<I, B>
```
Added in v0.9.4
## chainFirst
**Signature**
```ts
export declare const chainFirst: <A, E, B>(
f: (a: A) => Decoder<E, B>,
) => (first: Decoder<E, A>) => Decoder<E, A>
```
Added in v0.9.4
## compose
**Signature**
```ts
export declare const compose: <A, O>(
second: Decoder<A, O>,
) => <I>(first: Decoder<I, A>) => Decoder<I, O>
```
Added in v0.9.4
## condemmMissingKeys
**Signature**
```ts
export declare const condemmMissingKeys: <I, A>(
decoder: Decoder<I, A>,
) => Decoder<I, UndoPartial<A>>
```
Added in v0.9.4
## condemn
**Signature**
```ts
export declare const condemn: <I, A>(decoder: Decoder<I, A>) => Decoder<I, A>
```
Added in v0.9.4
## condemnUnexpectedKeys
**Signature**
```ts
export declare const condemnUnexpectedKeys: <I, A>(decoder: Decoder<I, A>) => Decoder<I, A>
```
Added in v0.9.4
## condemnWhen
**Signature**
```ts
export declare function condemnWhen(predicate: Predicate<DE.DecodeError>)
```
Added in v0.9.4
## flap
**Signature**
```ts
export declare const flap: <A>(a: A) => <E, B>(fab: Decoder<E, (a: A) => B>) => Decoder<E, B>
```
Added in v0.9.4
## getApplicativeMonoid
**Signature**
```ts
export declare const getApplicativeMonoid: <A, E>(M: Monoid<A>) => Monoid<Decoder<E, A>>
```
Added in v0.9.4
## intersect
**Signature**
```ts
export declare const intersect: <A, B>(
second: Decoder<A, B>,
) => <C, D>(first: Decoder<C, D>) => Decoder<A & C, B & D>
```
Added in v0.9.6
## map
**Signature**
```ts
export declare const map: <A, B>(f: (value: A) => B) => <I>(decoder: Decoder<I, A>) => Decoder<I, B>
```
Added in v0.9.4
## nullable
**Signature**
```ts
export declare const nullable: <O2>(first: Decoder<unknown, O2>) => Decoder<unknown, O2 | null>
```
Added in v0.9.4
## optional
**Signature**
```ts
export declare const optional: <O2>(first: Decoder<unknown, O2>) => Decoder<unknown, O2 | undefined>
```
Added in v0.9.4
## refine
**Signature**
```ts
export declare const refine: <A, B>(
refinement: Refinement<A, B>,
id: string,
) => (from: Decoder<unknown, A>) => Decoder<unknown, B>
```
Added in v0.9.5
## strict
**Signature**
```ts
export declare const strict: <I, A>(decoder: Decoder<I, A>) => Decoder<I, UndoPartial<A>>
```
Added in v0.9.4
## tupled
**Signature**
```ts
export declare const tupled: <E, A>(fa: Decoder<E, A>) => Decoder<E, readonly [A]>
```
Added in v0.9.4
# Constructor
## Chain
**Signature**
```ts
export declare const Chain: Ch.Chain2<'@typed/fp/Decoder'>
```
Added in v0.9.4
## Do
**Signature**
```ts
export declare const Do: Decoder<unknown, {}>
```
Added in v0.9.4
## array
**Signature**
```ts
export declare const array: <O>(member: Decoder<unknown, O>) => Decoder<unknown, readonly O[]>
```
Added in v0.9.4
## boolean
**Signature**
```ts
export declare const boolean: Decoder<unknown, boolean>
```
Added in v0.9.4
## date
**Signature**
```ts
export declare const date: Decoder<unknown, Date>
```
Added in v0.9.6
## fromArray
**Signature**
```ts
export declare const fromArray: <O>(
member: Decoder<unknown, O>,
) => Decoder<readonly unknown[], readonly O[]>
```
Added in v0.9.4
## fromIO
**Signature**
```ts
export declare const fromIO: <A>(io: IO<A>) => Decoder<unknown, {}>
```
Added in v0.9.4
## fromRecord
**Signature**
```ts
export declare function fromRecord<A>(
decoder: Decoder<unknown, A>,
): Decoder<Readonly<Record<string, unknown>>, Readonly<Record<string, A>>>
```
Added in v0.9.4
## fromRefinement
**Signature**
```ts
export declare function fromRefinement<I, O extends I>(
refinement: Refinement<I, O>,
expected: string,
): Decoder<I, O>
```
Added in v0.9.4
## fromStruct
**Signature**
```ts
export declare const fromStruct: <A extends { readonly [key: string]: Decoder<unknown, any> }>(
properties: A,
) => Decoder<
Readonly<Record<string, unknown>>,
Partial<{ readonly [K in keyof A]: OutputOf<A[K]> }>
>
```
Added in v0.9.4
## fromTuple
**Signature**
```ts
export declare function fromTuple<A extends readonly unknown[]>(
...components: { readonly [K in keyof A]: Decoder<unknown, A[K]> }
): Decoder<readonly unknown[], A>
```
Added in v0.9.4
## lazy
**Signature**
```ts
export declare const lazy: <I, O>(id: string, f: () => Decoder<I, O>) => Decoder<I, O>
```
Added in v0.9.6
## literal
**Signature**
```ts
export declare const literal: <A extends readonly Literal[]>(
...literals: A
) => Decoder<unknown, A[number]>
```
Added in v0.9.6
## missingIndexes
**Signature**
```ts
export declare function missingIndexes<A extends readonly unknown[]>(
...components: { readonly [K in keyof A]: Decoder<unknown, A[K]> }
): Decoder<readonly unknown[], readonly unknown[]>
```
Added in v0.9.4
## missingKeys
**Signature**
```ts
export declare function missingKeys<A extends { readonly [key: string]: Decoder<unknown, any> }>(
properties: A,
): Decoder<Readonly<Record<string, unknown>>, Partial<{ readonly [K in keyof A]: OutputOf<A[K]> }>>
```
Added in v0.9.4
## number
**Signature**
```ts
export declare const number: Decoder<unknown, number>
```
Added in v0.9.4
## of
**Signature**
```ts
export declare const of: <A>(value: A) => Decoder<unknown, A>
```
Added in v0.9.4
## record
**Signature**
```ts
export declare const record: <O>(
codomain: Decoder<unknown, O>,
) => Decoder<unknown, Readonly<Record<string, O>>>
```
Added in v0.9.6
## string
**Signature**
```ts
export declare const string: Decoder<unknown, string>
```
Added in v0.9.4
## struct
**Signature**
```ts
export declare function struct<A extends { readonly [key: string]: Decoder<unknown, any> }>(
properties: A,
): Decoder<unknown, Partial<{ readonly [K in keyof A]: OutputOf<A[K]> }>>
```
Added in v0.9.4
## sum
**Signature**
```ts
export declare const sum: <T extends string>(
tag: T,
) => <A>(
members: { [K in keyof A]: Decoder<unknown, A[K] & Record<T, K>> },
) => Decoder<unknown, A[keyof A]>
```
Added in v0.9.6
## tuple
**Signature**
```ts
export declare function tuple<A extends readonly unknown[]>(
...components: { readonly [K in keyof A]: Decoder<unknown, A[K]> }
): Decoder<unknown, A>
```
Added in v0.9.4
## unexpectedIndexes
**Signature**
```ts
export declare function unexpectedIndexes<A extends readonly unknown[]>(
...components: { readonly [K in keyof A]: Decoder<unknown, A[K]> }
): Decoder<readonly unknown[], readonly unknown[]>
```
Added in v0.9.4
## unexpectedKeys
**Signature**
```ts
export declare function unexpectedKeys<A extends { readonly [key: string]: Decoder<unknown, any> }>(
properties: A,
): Decoder<Readonly<Record<string, unknown>>, Partial<{ readonly [K in keyof A]: OutputOf<A[K]> }>>
```
Added in v0.9.4
## union
**Signature**
```ts
export declare const union: <I, O1>(
second: Decoder<I, O1>,
) => <O2>(first: Decoder<I, O2>) => Decoder<I, O1 | O2>
```
Added in v0.9.4
## unknownArray
**Signature**
```ts
export declare const unknownArray: Decoder<unknown, readonly unknown[]>
```
Added in v0.9.4
## unknownRecord
**Signature**
```ts
export declare const unknownRecord: Decoder<unknown, { readonly [key: string]: unknown }>
```
Added in v0.9.4
# Decoder
## dateFromISOString
**Signature**
```ts
export declare const dateFromISOString: Decoder<string, Date>
```
Added in v0.9.5
## jsonParse
**Signature**
```ts
export declare const jsonParse: Decoder<unknown, Json>
```
Added in v0.9.5
## jsonParseFromString
**Signature**
```ts
export declare const jsonParseFromString: Decoder<string, Json>
```
Added in v0.9.5
# Instance
## Applicative
**Signature**
```ts
export declare const Applicative: App.Applicative2<'@typed/fp/Decoder'>
```
Added in v0.9.4
## Apply
**Signature**
```ts
export declare const Apply: Ap.Apply2<'@typed/fp/Decoder'>
```
Added in v0.9.4
## Functor
**Signature**
```ts
export declare const Functor: F.Functor2<'@typed/fp/Decoder'>
```
Added in v0.9.4
## Monad
**Signature**
```ts
export declare const Monad: Monad2<'@typed/fp/Decoder'>
```
Added in v0.9.4
## Pointed
**Signature**
```ts
export declare const Pointed: Pointed2<'@typed/fp/Decoder'>
```
Added in v0.9.4
## Schemable
**Signature**
```ts
export declare const Schemable: Schemable2C<'@typed/fp/Decoder', unknown>
```
Added in v0.9.5
## WithRefine
**Signature**
```ts
export declare const WithRefine: WithRefine2C<'@typed/fp/Decoder', unknown>
```
Added in v0.9.5
## WithUnion
**Signature**
```ts
export declare const WithUnion: WithUnion2C<'@typed/fp/Decoder', unknown>
```
Added in v0.9.5
# Interpreter
## assert
Throw if not a valid decoder. Absolves optional errors
**Signature**
```ts
export declare const assert: <I, O>(decoder: Decoder<I, O>) => (i: I) => O
```
Added in v0.9.5
## assertStrict
Throw if not a valid decoder. Condemns optional errors
**Signature**
```ts
export declare const assertStrict: <I, O>(decoder: Decoder<I, O>) => (i: I) => Required<O>
```
Added in v0.9.5
# Model
## Decoder (interface)
**Signature**
```ts
export interface Decoder<I, O> {
readonly decode: (input: I) => T.These<DE.DecodeErrors, O>
}
```
Added in v0.9.4
# Refinement
## isDate
**Signature**
```ts
export declare const isDate: (x: unknown) => x is Date
```
Added in v0.9.6
# Type-level
## InputOf (type alias)
**Signature**
```ts
export type InputOf<A> = [A] extends [Decoder<infer I, any>] ? I : never
```
Added in v0.9.4
## OutputOf (type alias)
**Signature**
```ts
export type OutputOf<A> = [A] extends [Decoder<any, infer O>] ? O : never
```
Added in v0.9.4
# Typeclass Constructor
## getApplySemigroup
**Signature**
```ts
export declare const getApplySemigroup: <A, E>(S: Semigroup<A>) => Semigroup<Decoder<E, A>>
```
Added in v0.9.4
# URI
## URI
**Signature**
```ts
export declare const URI: '@typed/fp/Decoder'
```
Added in v0.9.4
## URI (type alias)
**Signature**
```ts
export type URI = typeof URI
```
Added in v0.9.4