@unsplash/sum-types-fp-ts/dist/types/index.d.ts

fp-ts bindings for @unsplash/sum-types.

/**
 * @since 0.1.0
 */
import * as Sum from "@unsplash/sum-types";
import { Eq } from "fp-ts/Eq";
import { Ord } from "fp-ts/Ord";
import { Show } from "fp-ts/Show";
declare type Tag<A> = A extends Sum.Member<infer B, any> ? B : never;
declare type Value<A> = A extends Sum.Member<any, infer B> ? B : never;
declare type Nullary = Sum.Member<string>;
declare type Eqs<A extends Sum.AnyMember> = readonly [A] extends readonly [Nullary] ? Record<string, never> : {
    readonly [B in A as Value<B> extends null ? never : Tag<B>]: Eq<Value<B>>;
};
declare type Ords<A extends Sum.AnyMember> = readonly [A] extends readonly [Nullary] ? Record<string, never> : {
    readonly [B in A as Value<B> extends null ? never : Tag<B>]: Ord<Value<B>>;
};
declare type Shows<A extends Sum.AnyMember> = readonly [A] extends readonly [Nullary] ? Record<string, never> : {
    readonly [B in A as Value<B> extends null ? never : Tag<B>]: Show<Value<B>>;
};
/**
 * Given an `Eq` instance for each member of `A` for which there's a value,
 * returns an `Eq` instance for all `A`.
 *
 * @example
 * import { Member, create } from '@unsplash/sum-types'
 * import { getEq } from '@unsplash/sum-types-fp-ts'
 * import * as Num from 'fp-ts/number'
 *
 * type Weather
 *   = Member<'Sun'>
 *   | Member<'Rain', number>
 *
 * const { mk: { Sun, Rain }, match } = create<Weather>()
 *
 * const eqWeather = getEq<Weather>({
 *   Rain: Num.Eq,
 * })
 *
 * assert.strictEqual(eqWeather.equals(Rain(1), Rain(1)), true)
 * assert.strictEqual(eqWeather.equals(Rain(1), Sun), false)
 * assert.strictEqual(eqWeather.equals(Rain(1), Rain(2)), false)
 *
 * @since 0.1.0
 */
export declare const getEq: <A extends Sum.AnyMember>(eqs: Eqs<A>) => Eq<A>;
/**
 * Given an `Ord` instance for each member of `A` for which there's a value,
 * returns an `Ord` instance for all `A`.
 *
 * Note that whereas Haskell derives `Ord` across members based upon definition
 * order, this function instead does so alphabetically.
 *
 * @example
 * import { Member, create } from '@unsplash/sum-types'
 * import { getOrd } from '@unsplash/sum-types-fp-ts'
 * import * as Num from 'fp-ts/number'
 *
 * type Weather
 *   = Member<'Sun'>
 *   | Member<'Rain', number>
 *
 * const { mk: { Sun, Rain }, match } = create<Weather>()
 *
 * const ordWeather = getOrd<Weather>({
 *   Rain: Num.Ord,
 * })
 *
 * assert.strictEqual(ordWeather.compare(Rain(1), Rain(1)), 0)
 * assert.strictEqual(ordWeather.compare(Rain(1), Sun), -1)
 * assert.strictEqual(ordWeather.compare(Rain(1), Rain(2)), -1)
 * assert.strictEqual(ordWeather.compare(Rain(2), Rain(1)), 1)
 *
 * @since 0.1.0
 */
export declare const getOrd: <A extends Sum.AnyMember>(ords: Ords<A>) => Ord<A>;
/**
 * Given a `Show` instance for each member of `A` for which there's a value,
 * returns a `Show` instance for all `A`.
 *
 * @example
 * import { Member, create } from '@unsplash/sum-types'
 * import { getShow } from '@unsplash/sum-types-fp-ts'
 * import * as Num from 'fp-ts/number'
 *
 * type Weather
 *   = Member<'Sun'>
 *   | Member<'Rain', number>
 *
 * const { mk: { Sun, Rain }, match } = create<Weather>()
 *
 * const showWeather = getShow<Weather>({
 *   Rain: Num.Show,
 * })
 *
 * assert.strictEqual(showWeather.show(Sun), 'Sun')
 * assert.strictEqual(showWeather.show(Rain(1)), 'Rain(1)')
 *
 * @since 0.1.0
 */
export declare const getShow: <A extends Sum.AnyMember>(shows: Shows<A>) => Show<A>;
export {};
//# sourceMappingURL=index.d.ts.map