perlica
Version:
> [!WARNING] > 🚧 Work in progress!
98 lines (97 loc) • 4.92 kB
TypeScript
/**
* |----------------------|------------------|
* | Rust methods | Perlica |
* |----------------------|------------------|
* | and | and |
* | and_then | andThen |
* | as_deref | |
* | as_deref_mut | |
* | as_mut | |
* | as_ref | |
* | cloned | |
* | copied | |
* | err | err |
* | expect | expect |
* | expect_err | expectErr |
* | flatten | flatten |
* | inspect | inspect |
* | inspect_err | inspectErr |
* | into_err | |
* | into_ok | |
* | is_err | isErr |
* | is_err_and | isErrAnd |
* | is_ok | isOk |
* | is_ok_and | isOkAnd |
* | iter | |
* | iter_mut | |
* | map | map |
* | map_err | mapErr |
* | map_or | mapOr |
* | map_or_else | mapOrElse |
* | ok | ok |
* | or | or |
* | or_else | orElse |
* | transpose | transpose |
* | unwrap | unwrap |
* | unwrap_err | unwrapErr |
* | unwrap_err_unchecked | |
* | unwrap_or | unwrapOr |
* | unwrap_or_default | |
* | unwrap_or_else | unwrapOrElse |
* | unwrap_unchecked | |
* |----------------------|------------------|
*/
import { OnceIterator } from "./Iterator";
import { type Option } from "./Option";
export type OkType<R> = R extends Result<infer T, any> ? T : any;
export type ErrType<R> = R extends Result<any, infer E> ? E : any;
export interface ResultTrait<T, E> {
and<U, T, E>(this: Result<T, E>, f: (v: T) => U): Result<U, E>;
andThen<U, T, E>(this: Result<T, E>, f: (v: T) => Result<U, E>): Result<U, E>;
err<T, E>(this: Result<T, E>): Option<E>;
expect<T, E>(this: Result<T, E>, msg: string): T;
expectErr<T, E>(this: Result<T, E>, msg: string): E;
flatten<T, E>(this: Result<Result<T, E>, E>): Result<T, E>;
inspect: <T, E>(this: Result<T, E>, f: (v: T) => void) => Result<T, E>;
inspectErr<T, E>(this: Result<T, E>, f: (v: E) => void): Result<T, E>;
isErr<T, E>(this: Result<T, E>): boolean;
isErrAnd<T, E>(this: Result<T, E>, f: (v: E) => boolean): boolean;
isOk<T, E>(this: Result<T, E>): boolean;
isOkAnd<T, E>(this: Result<T, E>, f: (v: T) => boolean): boolean;
map<U, T, E>(this: Result<T, E>, f: (v: T) => U): Result<U, E>;
mapErr<U, T, E>(this: Result<T, E>, f: (v: E) => U): Result<T, U>;
mapOr<U, T, E>(this: Result<T, E>, def: U, f: (v: T) => U): U;
mapOrElse<U, T, E>(this: Result<T, E>, def: (v: E) => U, f: (v: T) => U): U;
ok<T, E>(this: Result<T, E>): Option<T>;
or<U, T, E>(this: Result<T, E>, f: (v: E) => U): Result<T, U>;
orElse<U, T, E>(this: Result<T, E>, f: (v: E) => Result<T, U>): Result<T, U>;
transpose<T, E>(this: Result<Option<T>, E>): Option<Result<T, E>>;
unwrap<T, E>(this: Result<T, E>): T;
unwrapErr<T, E>(this: Result<T, E>): E;
unwrapOr<T, E>(this: Result<T, E>, def: T): T;
unwrapOrElse<T, E>(this: Result<T, E>, def: (v: E) => T): T;
[Symbol.iterator](this: Result<T, E>): OnceIterator<Result<T, E>, T>;
}
export declare const isOk: <T, E>(r: Result<T, E>) => r is Ok<T>;
export declare const isErr: <T, E>(r: Result<T, E>) => r is Err<E>;
export interface Ok<T> extends ResultTrait<T, never> {
tag: "ok";
value: T;
}
export interface Err<E> extends ResultTrait<never, E> {
tag: "err";
value: E;
}
export type Result<T, E> = Ok<T> | Err<E>;
export declare const ResultProto: <T, E>() => ResultTrait<T, E>;
export declare const fromNullable: <T, E>(v: T, f: () => E) => Result<T, E>;
export declare const fromOption: <T, E>(v: Option<T>, f: () => E) => Result<T, E>;
export declare const tryCatch: <T, E>(f: () => T) => Result<T, E>;
export declare const tryPromise: <T, E>(v: Promise<T>) => Promise<Result<T, E>>;
export declare const ok: <T, E = never>(v: T) => Result<T, E>;
export declare const err: <E, T = never>(v: E) => Result<T, E>;
interface Bind {
<T extends Result<any, any>, R>(fn: () => Generator<T, R>): Result<R, T extends Err<infer E> ? E : never>;
}
export declare const bind: Bind;
export {};