78 lines
1.7 KiB
TypeScript
78 lines
1.7 KiB
TypeScript
export class Result<T, E = Error> {
|
|
private constructor(
|
|
private readonly _value?: T,
|
|
private readonly _error?: E,
|
|
private readonly _isSuccess: boolean = true
|
|
) {}
|
|
|
|
static ok<T, E = Error>(value: T): Result<T, E> {
|
|
return new Result<T, E>(value, undefined, true);
|
|
}
|
|
|
|
static err<T, E = Error>(error: E): Result<T, E> {
|
|
return new Result<T, E>(undefined, error, false);
|
|
}
|
|
|
|
isOk(): boolean {
|
|
return this._isSuccess;
|
|
}
|
|
|
|
isErr(): boolean {
|
|
return !this._isSuccess;
|
|
}
|
|
|
|
unwrap(): T {
|
|
if (!this._isSuccess) {
|
|
throw new Error('Called unwrap on an error result');
|
|
}
|
|
return this._value!;
|
|
}
|
|
|
|
unwrapOr(defaultValue: T): T {
|
|
return this._isSuccess ? this._value! : defaultValue;
|
|
}
|
|
|
|
unwrapErr(): E {
|
|
if (this._isSuccess) {
|
|
throw new Error('Called unwrapErr on a success result');
|
|
}
|
|
return this._error!;
|
|
}
|
|
|
|
map<U>(fn: (value: T) => U): Result<U, E> {
|
|
if (this._isSuccess) {
|
|
return Result.ok(fn(this._value!));
|
|
}
|
|
return Result.err(this._error!);
|
|
}
|
|
|
|
mapErr<F>(fn: (error: E) => F): Result<T, F> {
|
|
if (!this._isSuccess) {
|
|
return Result.err(fn(this._error!));
|
|
}
|
|
return Result.ok(this._value!);
|
|
}
|
|
|
|
andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E> {
|
|
if (this._isSuccess) {
|
|
return fn(this._value!);
|
|
}
|
|
return Result.err(this._error!);
|
|
}
|
|
|
|
/**
|
|
* Direct access to the value (for testing convenience).
|
|
* Prefer using unwrap() in production code.
|
|
*/
|
|
get value(): T | undefined {
|
|
return this._value;
|
|
}
|
|
|
|
/**
|
|
* Direct access to the error (for testing convenience).
|
|
* Prefer using unwrapErr() in production code.
|
|
*/
|
|
get error(): E | undefined {
|
|
return this._error;
|
|
}
|
|
} |