true-myth/dist/toolbelt.js

A library for safe functional programming in JavaScript, with first-class support for TypeScript

/**
  Tools for working easily with `Maybe` and `Result` *together*... but which do
  not *require* you to use both. If they were in the `true-myth/maybe` or
  `true-myth/result` modules, then importing either would always include the
  other. While that is not usually a concern with bundlers, it *is* an issue
  when using dynamic imports or otherwise doing runtime resolution in a browser
  or similar environment.

  The flip side of that is: importing from *this* module *does* require access
  to both `Maybe` and `Result` modules.

  @module
 */
import Result from './result.js';
import Maybe from './maybe.js';
import { curry1 } from './-private/utils.js';
/**
  Transposes a {@linkcode Result} of a {@linkcode Maybe} into a `Maybe` of a
  `Result`.

  | Input         | Output         |
  | ------------- | -------------- |
  | `Ok(Just(T))` | `Just(Ok(T))`  |
  | `Err(E)`      | `Just(Err(E))` |
  | `Ok(Nothing)` | `Nothing`      |

  @param result a `Result<Maybe<T>, E>` to transform to a `Maybe<Result<T, E>>`.
 */
export function transposeResult(result) {
    return result.match({
        Ok: (maybe) => maybe.match({
            Just: (v) => Maybe.just(Result.ok(v)),
            Nothing: () => Maybe.nothing(),
        }),
        Err: (e) => Maybe.just(Result.err(e)),
    });
}
/**
  Convert a {@linkcode Result} to a {@linkcode Maybe}.

  The converted type will be {@linkcode "maybe".Just Just} if the `Result` is
  {@linkcode "result".Ok Ok} or {@linkcode "maybe".Nothing Nothing} if the
  `Result` is {@linkcode "result".Err Err}; the wrapped error value will be
  discarded.

  @param result The `Result` to convert to a `Maybe`
  @returns      `Just` the value in `result` if it is `Ok`; otherwise `Nothing`
 */
export function toMaybe(result) {
    return result.isOk ? Maybe.just(result.value) : Maybe.nothing();
}
export function fromMaybe(errValue, maybe) {
    const op = (m) => (m.isJust ? Result.ok(m.value) : Result.err(errValue));
    return curry1(op, maybe);
}
/**
  Transposes a {@linkcode Maybe} of a {@linkcode Result} into a `Result` of a
  `Maybe`.

  | Input          | Output        |
  | -------------- | ------------- |
  | `Just(Ok(T))`  | `Ok(Just(T))` |
  | `Just(Err(E))` | `Err(E)`      |
  | `Nothing`      | `Ok(Nothing)` |

  @param maybe a `Maybe<Result<T, E>>` to transform to a `Result<Maybe<T>, E>>`.
 */
export function transposeMaybe(maybe) {
    return maybe.match({
        Just: (result) => result.match({
            Ok: (v) => Result.ok(Maybe.just(v)),
            Err: (e) => Result.err(e),
        }),
        Nothing: () => Result.ok(Maybe.nothing()),
    });
}
export function toOkOrErr(error, maybe) {
    const op = (m) => (m.isJust ? Result.ok(m.value) : Result.err(error));
    return maybe !== undefined ? op(maybe) : op;
}
export function toOkOrElseErr(elseFn, maybe) {
    const op = (m) => (m.isJust ? Result.ok(m.value) : Result.err(elseFn()));
    return curry1(op, maybe);
}
/**
  Construct a {@linkcode "maybe".Maybe Maybe<T>} from a
  {@linkcode "result".Result Result<T, E>}.

  If the `Result` is a {@linkcode "result".Ok Ok}, wrap its value in {@linkcode
  "maybe".Just Just}. If the `Result` is an {@linkcode "result".Err Err}, throw
  away the wrapped `E` and transform to a {@linkcode "maybe".Nothing Nothing}.

  @template T  The type of the value wrapped in a {@linkcode "result".Ok Ok} and
    therefore in the {@linkcode "maybe".Just Just} of the resulting `Maybe`.
  @param result The `Result` to construct a `Maybe` from.
  @returns      `Just` if `result` was `Ok` or `Nothing` if it was `Err`.
 */
export function fromResult(result) {
    return result.isOk ? Maybe.just(result.value) : Maybe.nothing();
}
//# sourceMappingURL=toolbelt.js.map