Interface Result<ResultType, ErrorType>

interface Result<ResultType, ErrorType extends Error> {
    get "[toStringTag]"(): "Result";
    is_error(): this is ErrorResult<ErrorType>;
    is_ok(): this is OkResult<ResultType>;
    value_or(value_if_error: ResultType): ResultType;
    error_or(error_if_ok: ErrorType): ErrorType;
    map<NewResultType>(
        fn: (value: ResultType) => NewResultType,
    ): Result<NewResultType, ErrorType>;
    map_err<NewErrorType extends Error>(
        fn: (error: ErrorType) => NewErrorType,
    ): Result<ResultType, NewErrorType>;
    match<OKMatchResultType, ErrorMatchResultType>(
        handlers: {
            on_ok: (value: ResultType) => OKMatchResultType;
            on_error: (error: ErrorType) => ErrorMatchResultType;
        },
    ): OKMatchResultType
    | ErrorMatchResultType;
    and_then<NewResultType>(
        fn: (value: ResultType) => Result<NewResultType, ErrorType>,
    ): Result<NewResultType, ErrorType>;
    or_else<NewErrorType extends Error>(
        fn: (error: ErrorType) => Result<ResultType, NewErrorType>,
    ): Result<ResultType, NewErrorType>;
    "[iterator]"(): Generator<ResultType, void, unknown>;
}

Type Parameters

ResultType
ErrorType extends Error

Index

Accessors

[toStringTag]

Methods

is_error is_ok value_or error_or map map_err match and_then or_else [iterator]

Accessors

[toStringTag]

get "[toStringTag]"(): "Result"
Returns the string tag for Object.prototype.toString calls. Always returns "Result" for Result instances.

Returns "Result"
- Defined in src/result/result.ts:64

Methods

is_error

is_error(): this is ErrorResult<ErrorType>
Type predicate that checks if this Result contains an error. If true, TypeScript will narrow the type to include the error property.

Returns this is ErrorResult<ErrorType>
True if this Result contains an error, false if it contains a value
Example
```
const result = result.error(new Error("Something went wrong"));
if (result.is_error()) {
  console.log(result.error.message); // TypeScript knows .error exists
}
```
- Defined in src/result/result.ts:80

is_ok

is_ok(): this is OkResult<ResultType>
Type predicate that checks if this Result contains a success value. If true, TypeScript will narrow the type to include the value property.

Returns this is OkResult<ResultType>
True if this Result contains a value, false if it contains an error
Example
```
const result = result.ok("Hello, World!");
if (result.is_ok()) {
  console.log(result.value); // TypeScript knows .value exists
}
```
- Defined in src/result/result.ts:96

value_or

value_or(value_if_error: ResultType): ResultType
Returns the contained value if Ok, otherwise returns the provided default value.
Parameters
- value_if_error: ResultType
  The value to return if this Result contains an error
Returns ResultType
The contained value if Ok, otherwise the default value
Example
```
const success = result.ok(42);
console.log(success.value_or(0)); // 42

const failure = result.error(new Error("Failed"));
console.log(failure.value_or(0)); // 0
```
- Defined in src/result/result.ts:113

error_or

error_or(error_if_ok: ErrorType): ErrorType
Returns the contained error if Error, otherwise returns the provided default error.
Parameters
- error_if_ok: ErrorType
  The error to return if this Result contains a value
Returns ErrorType
The contained error if Error, otherwise the default error
Example
```
const failure = result.error(new Error("Original error"));
console.log(failure.error_or(new Error("Default"))); // Error: Original error

const success = result.ok("value");
console.log(success.error_or(new Error("Default"))); // Error: Default
```
- Defined in src/result/result.ts:130

map

map<NewResultType>(
fn: (value: ResultType) => NewResultType,
): Result<NewResultType, ErrorType>
Transforms the contained value if Ok, otherwise returns the error unchanged. This is the functor map operation for Result.
Type Parameters
- NewResultType
  The type of the transformed value
Parameters
- fn: (value: ResultType) => NewResultType
  Function to transform the value if Ok
Returns Result<NewResultType, ErrorType>
A new Result with the transformed value if Ok, otherwise the original error
Example
```
const success = result.ok(5);
const doubled = success.map(x => x * 2);
console.log(doubled.value_or(0)); // 10

const failure = result.error(new Error("Failed"));
const transformed = failure.map(x => x * 2); // fn is not called
console.log(transformed.is_error()); // true
```
- Defined in src/result/result.ts:151

map_err

map_err<NewErrorType extends Error>(
fn: (error: ErrorType) => NewErrorType,
): Result<ResultType, NewErrorType>
Transforms the contained error if Error, otherwise returns the value unchanged. This allows for error transformation and chaining.
Type Parameters
- NewErrorType extends Error
  The type of the transformed error
Parameters
- fn: (error: ErrorType) => NewErrorType
  Function to transform the error if Error
Returns Result<ResultType, NewErrorType>
A new Result with the transformed error if Error, otherwise the original value
Example
```
const failure = result.error(new Error("Original"));
const wrapped = failure.map_err(err => new Error(`Wrapped: ${err.message}`));
if (wrapped.is_error()) {
  console.log(wrapped.error.message); // "Wrapped: Original"
}

const success = result.ok("value");
const unchanged = success.map_err(err => new Error("Won't be called"));
console.log(unchanged.is_ok()); // true
```
- Defined in src/result/result.ts:176

match

match<OKMatchResultType, ErrorMatchResultType>(
    handlers: {
        on_ok: (value: ResultType) => OKMatchResultType;
        on_error: (error: ErrorType) => ErrorMatchResultType;
    },
): OKMatchResultType
| ErrorMatchResultType
Pattern matches against the Result, executing the appropriate callback and returning its result. This is useful when you need to transform both Ok and Error cases into the same output type.
Type Parameters
- OKMatchResultType
  The return type of the on_ok callback
- ErrorMatchResultType
  The return type of the on_error callback
Parameters
- handlers: {
  on_ok: (value: ResultType) => OKMatchResultType;
  on_error: (error: ErrorType) => ErrorMatchResultType;
  }
  Object containing callback functions for Ok and Error cases
  - on_ok: (value: ResultType) => OKMatchResultType
    Function to execute if Result is Ok, receiving the value
  - on_error: (error: ErrorType) => ErrorMatchResultType
    Function to execute if Result is Error, receiving the error
Returns OKMatchResultType | ErrorMatchResultType
The result of the executed callback
Example
```
const success = result.ok(42);
const message = success.match({
  on_ok: (value) => `Value is ${value}`,
  on_error: (error) => `Error occurred: ${error.message}`,
});
console.log(message); // "Value is 42"

const failure = result.error(new Error("Something went wrong"));
const errorMessage = failure.match({
  on_ok: (value) => `Value is ${value}`,
  on_error: (error) => `Error occurred: ${error.message}`,
});
console.log(errorMessage); // "Error occurred: Something went wrong"
```
- Defined in src/result/result.ts:208

and_then

and_then<NewResultType>(
fn: (value: ResultType) => Result<NewResultType, ErrorType>,
): Result<NewResultType, ErrorType>
Monadic bind operation. Chains another Result-returning operation if this Result is Ok. If this Result is Error, the function is not called and the error is propagated. This is also known as flatMap in some languages.
Type Parameters
- NewResultType
  The type of the value in the returned Result
Parameters
- fn: (value: ResultType) => Result<NewResultType, ErrorType>
  Function that takes the Ok value and returns a new Result
Returns Result<NewResultType, ErrorType>
The Result returned by fn if Ok, otherwise the original error
Example
```
function parseNumber(str: string): Result<number, Error> {
  const num = Number(str);
  return isNaN(num) ? result.error(new Error("Not a number")) : result.ok(num);
}

function divide(a: number, b: number): Result<number, Error> {
  return b === 0 ? result.error(new Error("Division by zero")) : result.ok(a / b);
}

const computation = parseNumber("10")
  .and_then(num => divide(num, 2));

if (computation.is_ok()) {
  console.log(computation.value); // 5
}
```
- Defined in src/result/result.ts:244

or_else

or_else<NewErrorType extends Error>(
fn: (error: ErrorType) => Result<ResultType, NewErrorType>,
): Result<ResultType, NewErrorType>
Provides a fallback Result if this Result is Error. If this Result is Ok, the function is not called and the value is preserved. This allows for error recovery and alternative computation paths.
Type Parameters
- NewErrorType extends Error
  The type of error in the fallback Result
Parameters
- fn: (error: ErrorType) => Result<ResultType, NewErrorType>
  Function that takes the Error and returns a fallback Result
Returns Result<ResultType, NewErrorType>
The fallback Result returned by fn if Error, otherwise the original Ok value
Example
```
function tryPrimary(): Result<string, Error> {
  return result.error(new Error("Primary failed"));
}

function tryFallback(): Result<string, Error> {
  return result.ok("Fallback success");
}

const outcome = tryPrimary()
  .or_else(() => tryFallback());

if (outcome.is_ok()) {
  console.log(outcome.value); // "Fallback success"
}
```
- Defined in src/result/result.ts:275

[iterator]

"[iterator]"(): Generator<ResultType, void, unknown>

Returns a generator that yields the contained value if this Result is Ok. If this Result is Error, the generator yields nothing (completes immediately). This allows for easy iteration over successful values in for-of loops and other iterator contexts.

Returns Generator<ResultType, void, unknown>

A generator that yields the value if Ok, otherwise yields nothing

Example

const success = result.ok(42);
for (const value of success) {
  console.log(value); // 42
}

const failure = result.error(new Error("Failed"));
for (const value of failure) {
  console.log("This won't execute");
}

// Useful for collecting successful values from multiple results
const results = [
  result.ok(1),
  result.error(new Error("Failed")),
  result.ok(3)
];

const values = [];
for (const res of results) {
  for (const value of res) {
    values.push(value);
  }
}
console.log(values); // [1, 3]

Interface Result<ResultType, ErrorType>

Type Parameters

Index

Accessors

Methods

Accessors

[toStringTag]

Returns "Result"

Methods

is_error

Returns this is ErrorResult<ErrorType>

Example

is_ok

Returns this is OkResult<ResultType>

Example

value_or

Parameters

Returns ResultType

Example

error_or

Parameters

Returns ErrorType

Example

map

Type Parameters

Parameters

Returns Result<NewResultType, ErrorType>

Example

map_err

Type Parameters

Parameters

Returns Result<ResultType, NewErrorType>

Example

match

Type Parameters

Parameters

on_ok: (value: ResultType) => OKMatchResultType

on_error: (error: ErrorType) => ErrorMatchResultType

Returns OKMatchResultType | ErrorMatchResultType

Example

and_then

Type Parameters

Parameters

Returns Result<NewResultType, ErrorType>

Example

or_else

Type Parameters

Parameters

Returns Result<ResultType, NewErrorType>

Example

[iterator]

Returns Generator<ResultType, void, unknown>

Example

Settings

On This Page