option-t/esm/deprecated/plain_option/transpose.js

A toolkit of Nullable/Option/Result type implementation in ECMAScript. Their APIs are inspired by Rust's `Option<T>` and `Result<T, E>`.

import { createOk, createErr, isErr, unwrapErr, unwrapOk, } from '../../plain_result/core/result.js';
import { isNone, createSome, createNone } from './option.js';
/**
 *  Transposes an `Option` of a `Result` into a `Result` of an `Option`.
 *
 *  - `Some(Ok(x))` -> `Ok(Some(x))`
 *  - `Some(Err(e))` -> `Err(e)`
 *  - `None` => `Ok(None)`
 */
export function transposeOptionToResult(input) {
    if (isNone(input)) {
        const inner = createNone();
        const result = createOk(inner);
        return result;
    }
    const inner = input.val;
    if (isErr(inner)) {
        const err = unwrapErr(inner);
        const result = createErr(err);
        return result;
    }
    const innerInner = unwrapOk(inner);
    const some = createSome(innerInner);
    const result = createOk(some);
    return result;
}
/**
 *  Transposes a `Result` of an `Option` into an `Option` of a `Result`.
 *
 *  - `Ok(Some(v))` -> `Some(Ok(v))`
 *  - `Ok(None)` -> `None`
 *  - `Err(e)` -> `Some(Err(e))`
 */
export function transposeResultToOption(input) {
    if (isErr(input)) {
        const err = unwrapErr(input);
        const newErr = createErr(err);
        const result = createSome(newErr);
        return result;
    }
    const inner = unwrapOk(input);
    if (isNone(inner)) {
        const result = createNone();
        return result;
    }
    const innerInner = inner.val;
    const innerV = createOk(innerInner);
    const result = createSome(innerV);
    return result;
}