rivo/Result/Map.d.ts

🤖 The ultimate library you need for composable type-level programming in TypeScript, powered by HKT.

// @ts-ignore - `Err` is only used in doc comments
import type { Err, Ok, Result } from ".";
import type {
  Args,
  Call1W,
  Fn1,
  GenericFn,
  GenericResolver,
  GenericReturn1W,
  Param0,
  Return,
} from "../HKT";

/**
 * Apply a function to a {@link Result} value if it is {@link Ok}, otherwise return the {@link Err}.
 *
 * Sig: `<T, U, E>(f: (x: T) => U, r: Result<T, E>) => Result<U, E>`
 */
export type Map<F extends Fn1, R extends Result<unknown, unknown>> =
  R extends Ok<infer T> ? Ok<Call1W<F, T>> : R;

interface Resolver
  extends GenericResolver<[Fn1, Result<unknown, unknown>], Result<unknown, unknown>> {
  on1_: ([f]: Args<this>) => [
    [Result<Param0<typeof f>, unknown>],
    Result<Return<typeof f>, unknown>,
  ];
  on_1: ([, r]: Args<this>) => [
    [typeof r extends Result<infer T, infer E> ? Fn1<T, E> : never],
    Result<unknown, typeof r extends Result<unknown, infer E> ? E : never>,
  ];
  on11: ([f, r]: Args<this>) => [
    [],
    typeof r extends Result<infer T, infer E> ? Result<GenericReturn1W<typeof f, T>, E> : never,
  ];
}

/**
 * [Fn] Apply a function to a {@link Result} value if it is {@link Ok}, otherwise return the
 * {@link Err}.
 *
 * Sig: `<T, U, E>(f: (x: T) => U, r: Result<T, E>) => Result<U, E>`
 */
export default interface MapFn extends GenericFn<Resolver> {
  def: ([f, r]: Args<this>) => Map<typeof f, typeof r>;
}