Skip to main content

Interface: IResult<T, E>

A type used to express computations that can fail, it can be used for returning and propagating errors. This is a type union with the variants Ok(T), representing success and containing a value, and Err(E), representing error and containing an error value.

Typeparam

T The result's type.

Typeparam

E The error's type.

See

https://doc.rust-lang.org/std/result/index.html

Type parameters

Name
T
E

Implemented by

Methods

[iterator]

[iterator](): Generator<T, any, unknown>

Returns an iterator over the possibly contained value.

The iterator yields one value if the result is Ok, otherwise none.

Returns

Generator<T, any, unknown>

Example

const x = ok(7);
for (const value of x) {
console.log(value);
}
// Logs 7

Example

const x = err('Nothing!');
for (const value of x) {
console.log(value);
}
// Doesn't log

See

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:825


and

and<U>(result): Result<U, E>

Returns result if the result is Ok, otherwise returns the Err value of itself.

Type parameters

Name
U

Parameters

NameTypeDescription
resultResult<U, E>The result to check.

Returns

Result<U, E>

Example

const x: Result<number, string> = ok(2);
const y: Result<string, string> = err('Late error');
assert.equal(x.and(y), err('Late error'));

Example

const x: Result<number, string> = err('Early error');
const y: Result<string, string> = err('Late error');
assert.equal(x.and(y), err('Early error'));

Example

const x: Result<number, string> = ok(2);
const y: Result<string, string> = ok('Hello');
assert.equal(x.and(y), ok('Hello'));

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.and

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:573


andThen

andThen<U>(cb): Result<U, E>

Calls cb if the result is Ok, otherwise returns the Err value of self.

This function can be used for control flow based on Result values.

Type parameters

Name
U

Parameters

NameTypeDescription
cb(value: T) => Result<U, E>The predicate.

Returns

Result<U, E>

Example

function fractionOf4(value: number) {
return value === 0 ? err('overflowed') : ok(4 / value);
}

assert.equal(ok(2).andThen(fractionOf4), ok(4));
assert.equal(ok(0).andThen(fractionOf4), err('overflowed'));
assert.equal(err('not a number').andThen(fractionOf4), err('not a number'));

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.and_then

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:593


contains

contains(value): boolean

Returns true if the result is an Ok and the given value strict equals it.

Parameters

NameTypeDescription
valueTThe value to compare.

Returns

boolean

Example

const x: Result<number, string> = ok(2);
assert.equal(x.contains(2), true);

Example

const x: Result<number, string> = ok(3);
assert.equal(x.contains(2), false);

Example

const x: Result<number, string> = err('Some error message');
assert.equal(x.contains(2), false);

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.contains

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:671


containsErr

containsErr(error): boolean

Returns true if the result is an Err and the given error strict equals it.

Parameters

NameTypeDescription
errorEThe error to compare.

Returns

boolean

Example

const x: Result<number, string> = ok(2);
assert.equal(x.containsErr('Some error message'), false);

Example

const x: Result<number, string> = err('Some error message');
assert.equal(x.containsErr('Some error message'), true);

Example

const x: Result<number, string> = err('Some other error message');
assert.equal(x.containsErr('Some error message'), false);

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.contains_err

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:694


eq

eq(other): boolean

Checks whether or not other equals with self.

Parameters

NameTypeDescription
otherResult<T, E>The other result to compare.

Returns

boolean

See

https://doc.rust-lang.org/std/cmp/trait.PartialEq.html#tymethod.eq

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:767


err

err(): Option<E>

Converts from Result<T, E> to Option<E>.

Converts itself into an Option<E>, and discarding the successful value, if any.

Returns

Option<E>

Example

const x: Result<number, string> = ok(2);
assert.equal(x.err(), none);

Example

const x: Result<number, string> = err('Some error message');
assert.equal(x.err(), 'Some error message');

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.err

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:130


expect

expect(message): T

Returns the contained Ok value.

If the value is an Err, it throws a ResultError with the given message and the content of the Err.

Parameters

NameTypeDescription
messagestringThe message for the error.

Returns

T

Example

const x = ok(2);
assert.equal(x.expect('Whoops!'), 2);

Example

const x = err('Emergency failure');
assert.throws(() => x.expect('Whoops!'), {
name: 'ResultError',
message: 'Whoops',
value: 'Emergency failure'
});

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.expect

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:398


expectErr

expectErr(message): E

Returns the contained Err value.

If the value is an Ok, it throws a ResultError with the given message and the content of the Ok.

Parameters

NameTypeDescription
messagestringThe message for the error.

Returns

E

Example

const x = ok(2);
assert.throws(() => x.expectErr('Whoops!'), {
name: 'ResultError',
message: 'Whoops',
value: 2
});

Example

const x = err('Emergency failure');
assert.equal(x.expectErr('Whoops!'), 'Emergency failure');

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.expect_err

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:422


flatten

flatten<IT>(this): Result<IT, E>

Converts from Result<Result<T, E>, E> to Result<T, E>.

Type parameters

Name
IT

Parameters

NameType
thisResult<Result<IT, E>, E>

Returns

Result<IT, E>

Example

const x: Result<Result<string, number>, number> = ok(ok('Hello'));
assert.equal(x.flatten(), ok('Hello'));

Example

const x: Result<Result<string, number>, number> = ok(err(6));
assert.equal(x.flatten(), err(6));

Example

const x: Result<Result<string, number>, number> = err(6);
assert.equal(x.flatten(), err(6));

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.flatten

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:731


inspect

inspect(cb): this

Calls the provided closure with a reference to the contained value (if Ok).

Parameters

NameTypeDescription
cb(value: T) => voidThe predicate.

Returns

this

Seealso

inspectAsync for the awaitable version.

Example

ok(2).inspect(console.log);
// Logs: 2

Example

err('Some error message').inspect(console.log);
// Doesn't log

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.inspect

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:292


inspectAsync

inspectAsync(cb): Promise<IResult<T, E>>

Calls the provided closure with a reference to the contained value (if Ok) and awaits it.

Parameters

NameTypeDescription
cb(value: T) => Awaitable<void>The predicate.

Returns

Promise<IResult<T, E>>

Seealso

inspect for the sync version.

Example

await ok(2).inspectAsync(console.log);
// Logs: 2

Example

await err('Some error message').inspectAsync(console.log);
// Doesn't log

Note

This is an extension not supported in Rust

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:311


inspectErr

inspectErr(cb): this

Calls the provided closure with a reference to the contained error (if Err).

Parameters

NameTypeDescription
cb(error: E) => voidThe predicate.

Returns

this

Seealso

inspectErrAsync for the awaitable version.

Example

ok(2).inspectErr(console.log);
// Doesn't log

Example

err('Some error message').inspectErr(console.log);
// Logs: Some error message

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.inspect_err

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:330


inspectErrAsync

inspectErrAsync(cb): Promise<IResult<T, E>>

Calls the provided closure with a reference to the contained error (if Err) and awaits it.

Parameters

NameTypeDescription
cb(error: E) => Awaitable<void>The predicate.

Returns

Promise<IResult<T, E>>

Seealso

inspectErr for the sync version.

Example

await ok(2).inspectErrAsync(console.log);
// Doesn't log

Example

await err('Some error message').inspectErrAsync(console.log);
// Logs: Some error message

Note

This is an extension not supported in Rust

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:349


intoOkOrErr

intoOkOrErr(): T | E

Returns the Ok value if self is Ok, and the Err value if self is Err.

Returns

T | E

Example

let x: Result<number, number> = ok(3);
assert.equal(x.intoOkOrErr(), 3);

Example

let x: Result<number, number> = err(4);
assert.equal(x.intoOkOrErr(), 4);

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.into_ok_or_err

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:748


intoPromise

intoPromise(): Promise<Result<Awaited<T>, Awaited<E>>>

Returns a Promise object with the awaited value (if Ok) or the awaited error (if Err).

Returns

Promise<Result<Awaited<T>, Awaited<E>>>

Example

let x = ok(Promise.resolve(3));
assert.equal(await x.intoPromise(), ok(3));

Note

This is an extension not supported in Rust

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:760


isErr

isErr(): this is Err<E>

Returns true if the result is Err.

Returns

this is Err<E>

Example

const x = ok(-3);
assert.equal(x.isErr(), false);

Example

const x = err('Some error message');
assert.equal(x.isErr(), true);

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.is_err

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:69


isErrAnd

isErrAnd<R>(cb): this is Err<E> & R

Returns true if the result is Err and the value inside of it matches a predicate.

Type parameters

NameType
Rextends boolean

Parameters

NameTypeDescription
cb(error: E) => RThe predicate.

Returns

this is Err<E> & R

Example

const x = ok(2);
assert.equal(x.isErrAnd((error) => error instanceof TypeError), false);

Example

const x = err(new Error('Some error message'));
assert.equal(x.isErrAnd((error) => error instanceof TypeError), false);

Example

const x = err(new TypeError('Some error message'));
assert.equal(x.isErrAnd((error) => error instanceof TypeError), true);

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.is_err_and

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:92


isOk

isOk(): this is Ok<T>

Returns true if the result is Ok.

Returns

this is Ok<T>

Example

const x = ok(-3);
assert.equal(x.isOk(), true);

Example

const x = err('Some error message');
assert.equal(x.isOk(), false);

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.is_ok

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:30


isOkAnd

isOkAnd<R>(cb): this is Ok<T> & R

Returns true if the result is Ok and the value inside of it matches a predicate.

Type parameters

NameType
Rextends boolean

Parameters

NameType
cb(value: T) => R

Returns

this is Ok<T> & R

Example

const x = ok(2);
assert.equal(x.isOkAnd((value) => value > 1), true);

Example

const x = ok(0);
assert.equal(x.isOkAnd((value) => value > 1), false);

Example

const x = err('Some error message');
assert.equal(x.isOkAnd((value) => value > 1), false);

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.is_ok_and

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:52


iter

iter(): Generator<T, any, unknown>

Returns an iterator over the possibly contained value.

The iterator yields one value if the result is Ok, otherwise none.

Returns

Generator<T, any, unknown>

Example

const x = ok(7);
for (const value of x.iter()) {
console.log(value);
}
// Logs 7

Example

const x = err('Nothing!');
for (const value of x.iter()) {
console.log(value);
}
// Doesn't log

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.iter

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:374


map

map<U>(cb): Result<U, E>

Maps a Result<T, E> to Result<U, E> by applying a function to a contained Ok value, leaving an Err value untouched.

Type parameters

Name
U

Parameters

NameTypeDescription
cb(value: T) => UThe predicate.

Returns

Result<U, E>

Example

const x: Result<number, string> = ok(2);
assert.equal(x.map((value) => value * 2), ok(4));

Example

const x: Result<number, string> = err('Some error message');
assert.equal(x.map((value) => value * 2), err('Some error message'));

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.map

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:149


mapErr

mapErr<F>(cb): Result<T, F>

Maps a Result<T, E> to Result<T, F> by applying a function to a contained Err value, leaving an Ok value untouched.

This function can be used to pass through a successful result while handling an error.

Type parameters

Name
F

Parameters

NameTypeDescription
cb(error: E) => FThe predicate.

Returns

Result<T, F>

Example

const x: Result<number, Error> = ok(2);
assert.equal(x.mapErr((error) => error.message), ok(2));

Example

const x: Result<number, Error> = err(new Error('Some error message'));
assert.equal(x.mapErr((error) => error.message), err('Some error message'));

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.map_err

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:244


mapErrInto

mapErrInto<IT, IE>(cb): Result<T | IT, IE>

Maps a Result<T, E> to Result<T, F> by applying a function to a contained Err value, leaving an Ok value untouched.

This function can be used to pass through a successful result while handling an error.

Unlike mapErr, this method does not wrap the returned value inside Err, but instead, it returns the returned value.

Type parameters

Name
IT
IE

Parameters

NameTypeDescription
cb(error: E) => Result<IT, IE>The predicate.

Returns

Result<T | IT, IE>

Example

const x: Result<number, Error> = ok(2);
assert.equal(x.mapErrInto((error) => err(error.message)), ok(2));

Example

const x: Result<number, Error> = err(new Error('Some error message'));
assert.equal(x.mapErrInto((error) => err(error.message)), err('Some error message'));

Example

const x: Result<number, Error> = err(new Error('Some error message'));
assert.equal(x.mapErrInto((error) => ok(4)), ok(4));

Note

This is an extension not supported in Rust

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:273


mapInto

mapInto<IT, IE>(cb): Result<IT, E | IE>

Maps a Result<T, E> to Result<T, F> by applying a function to a contained Ok value, leaving an Err value untouched.

Unlike map, this method does not wrap the returned value inside Ok, but instead, it returns the returned value.

Type parameters

Name
IT
IE

Parameters

NameTypeDescription
cb(value: T) => Result<IT, IE>The predicate.

Returns

Result<IT, E | IE>

Example

const x: Result<number, string> = ok(2);
assert.equal(x.mapInto((value) => ok(value * value)), ok(4));

Example

const x: Result<number, string> = ok(0);
assert.equal(
x.mapInto((value) => (value === 0 ? err('zero is not divisible') : ok(1 / value))),
err('zero is not divisible')
);

Example

const x: Result<number, string> = err('Some error message');
assert.equal(x.mapInto((value) => ok(4)), err('Some error message'));

Note

This is an extension not supported in Rust

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:179


mapOr

mapOr<U>(defaultValue, cb): U

Returns the provided default (if Err), or applies a function to the contained value (if Ok),

Arguments passed to mapOr are eagerly evaluated; if you are passing the result of a function call, it is recommended to use mapOrElse, which is lazily evaluated.

Type parameters

Name
U

Parameters

NameTypeDescription
defaultValueUThe default value to use.
cb(value: T) => UThe predicate.

Returns

U

Example

const x = ok('hello');
assert.equal(x.mapOr(42, (value) => value.length), 5);

Example

const x = err('Some error message');
assert.equal(x.mapOr(42, (value) => value.length), 42);

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.map_or

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:201


mapOrElse

mapOrElse<U>(op, cb): U

Maps a Result<T, E> to U by applying fallback function default to a contained Err value, or function cb to a contained Ok value.

This function can be used to unpack a successful result while handling an error.

Type parameters

Name
U

Parameters

NameTypeDescription
op(error: E) => UThe predicate that is run on Err.
cb(value: T) => UThe predicate that is run on Ok.

Returns

U

Example

const x: Result<string, string> = ok('hello');
assert.equal(x.mapOrElse((error) => error.length, (value) => value.length), 5);

Example

const x: Result<string, string> = err('Some error message');
assert.equal(x.mapOrElse((error) => error.length, (value) => value.length), 18);

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.map_or_else

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:223


match

match<OkValue, ErrValue>(branches): OkValue | ErrValue

Runs ok function if self is Ok, otherwise runs err function.

Type parameters

Name
OkValue
ErrValue

Parameters

NameTypeDescription
branchesObjectThe branches to match.
branches.err(error: E) => ErrValue-
branches.ok(value: T) => OkValue-

Returns

OkValue | ErrValue

Example

const result = ok(4).match({
ok: (v) => v,
err: () => 0
});
assert.equal(result, 4);

Example

const result = err('Hello').match({
ok: (v) => v,
err: () => 0
});
assert.equal(result, 0);

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:796


ne

ne(other): boolean

Checks whether or not other doesn't equal with self.

Parameters

NameTypeDescription
otherResult<T, E>The other result to compare.

Returns

boolean

See

https://doc.rust-lang.org/std/cmp/trait.PartialEq.html#method.ne

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:774


ok

ok(): Option<T>

Converts from Result<T, E> to Option<T>.

Converts itself into an Option<T>, and discarding the error, if any.

Returns

Option<T>

Example

const x: Result<number, string> = ok(2);
assert.equal(x.ok(), some(2));

Example

const x: Result<number, string> = err('Some error message');
assert.equal(x.ok(), none);

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.ok

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:111


or

or<F>(result): Result<T, F>

Return result if the result is Err, otherwise returns the Ok value of self.

Arguments passed to or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use orElse, which is lazily evaluated.

Type parameters

Name
F

Parameters

NameTypeDescription
resultResult<T, F>The result to check.

Returns

Result<T, F>

Example

const x: Result<number, string> = ok(2);
const y: Result<number, string> = err('Late error');
assert.equal(x.or(y), ok(2));

Example

const x: Result<number, string> = err('Early error');
const y: Result<number, string> = ok(2);
assert.equal(x.or(y), ok(2));

Example

const x: Result<number, string> = err('Early error');
const y: Result<number, string> = err('Late error');
assert.equal(x.or(y), err('Late error'));

Example

const x: Result<number, string> = ok(2);
const y: Result<number, string> = ok(100);
assert.equal(x.or(y), ok(2));

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.or

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:628


orElse

orElse<F>(cb): Result<T, F>

Calls cb if the result is Err, otherwise returns the Ok value of self.

This function can be used for control flow based on result values.

Type parameters

Name
F

Parameters

NameTypeDescription
cb(error: E) => Result<T, F>The predicate.

Returns

Result<T, F>

Example

const square = (x: number): Result<number, string> => ok(x * x);
const wrapErr = (x: number): Result<number, string> => err(x);

assert.equal(ok(2).orElse(square).orElse(square), ok(2));
assert.equal(ok(2).orElse(wrapErr).orElse(square), ok(2));
assert.equal(err(3).orElse(square).orElse(wrapErr), ok(9));
assert.equal(err(3).orElse(wrapErr).orElse(wrapErr), err(3));

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.or_else

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:648


transpose

transpose<IT>(this): Option<Result<IT, E>>

Transposes a Result of an Option into an Option of a Result.

ok(none) will be mapped to none. ok(some(v)) and err(e) will be mapped to some(ok(v)) and some(err(e)).

Type parameters

Name
IT

Parameters

NameType
thisResult<Option<IT>, E>

Returns

Option<Result<IT, E>>

Example

const x: Result<Option<number>, Error> = ok(some(5));
const y: Option<Result<number, Error>> = some(ok(5));
assert.equal(x.transpose(), y);

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.transpose

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:709


unwrap

unwrap(): T

Returns the contained Ok value.

If the value is an Err, it throws a ResultError with the message, and the content of the Err.

Returns

T

Seealso

unwrapOr

Seealso

unwrapOrElse

Seealso

unwrapErr

Seealso

unwrapRaw

Example

const x = ok(2);
assert.equal(x.unwrap(), 2);

Example

const x = err('Emergency failure');
assert.throws(() => x.unwrap(), {
name: 'ResultError',
message: 'Unwrap failed',
value: 'Emergency failure'
});

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.unwrap

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:449


unwrapErr

unwrapErr(): E

Returns the contained Err value.

If the value is an Ok, it throws a ResultError with the message, and the content of the Ok.

Returns

E

Seealso

unwrap

Seealso

unwrapOr

Seealso

unwrapOrElse

Seealso

unwrapRaw

Example

const x = ok(2);
assert.throws(() => x.unwrapErr(), {
name: 'ResultError',
message: 'Unwrap failed',
value: 2
});

Example

const x = err('Emergency failure');
assert.equal(x.unwrapErr(), 'Emergency failure');

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.unwrap_err

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:476


unwrapOr

unwrapOr<V>(defaultValue): T | V

Returns the contained Ok value or the provided default.

Arguments passed to unwrapOr are eagerly evaluated; if you are passing the result of a function call, it is recommended to use unwrapOrElse, which is lazily evaluated.

Type parameters

Name
V

Parameters

NameTypeDescription
defaultValueVThe default value.

Returns

T | V

Seealso

unwrap

Seealso

unwrapOrElse

Seealso

unwrapErr

Seealso

unwrapRaw

Example

const x: Result<number, string> = ok(9);
assert.equal(x.unwrapOr(2), 9);

Example

const x: Result<number, string> = err('Error');
assert.equal(x.unwrapOr(2), 2);

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.unwrap_or

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:502


unwrapOrElse

unwrapOrElse<V>(op): T | V

Returns the contained Ok value or computes it from a closure.

Type parameters

Name
V

Parameters

NameTypeDescription
op(error: E) => VThe predicate.

Returns

T | V

Seealso

unwrap

Seealso

unwrapOr

Seealso

unwrapErr

Seealso

unwrapRaw

Example

const count = (x: string) => x.length;

assert.equal(ok(2).unwrapOrElse(count), 2);
assert.equal(err('hello').unwrapOrElse(count), 5);

See

https://doc.rust-lang.org/std/result/enum.Result.html#method.unwrap_or_else

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:522


unwrapRaw

unwrapRaw(): T

Returns the contained Ok value.

If the value is an Err, it throws the contained error.

Returns

T

Seealso

unwrap

Seealso

unwrapOr

Seealso

unwrapOrElse

Seealso

unwrapErr

Example

const x = ok(2);
assert.equal(x.unwrapRaw(), 2);

Example

const x = err('Emergency failure');
assert.throws(() => x.unwrapRaw(), {
name: 'Error',
message: 'Unwrap failed',
value: 'Emergency failure'
});

Defined in

node_modules/@sapphire/result/dist/esm/index.d.mts:547