Interface: IResult<T, E>
@sapphire/result.IResult
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.
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
Returns
Generator
<T
, any
, unknown
>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:863
and
▸ and<U
>(result
): Result
<U
, E
>
Returns result
if the result is Ok
, otherwise returns the Err
value of itself.
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
Type parameters
Name |
---|
U |
Parameters
Name | Type | Description |
---|---|---|
result | Result <U , E > | The result to check. |
Returns
Result
<U
, E
>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:601
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.
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
Type parameters
Name |
---|
U |
Parameters
Name | Type | Description |
---|---|---|
cb | (value : T ) => Result <U , E > | The predicate. |
Returns
Result
<U
, E
>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:622
contains
▸ contains(value
): boolean
Returns true
if the result is an Ok
and the given value strict equals it.
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
Parameters
Name | Type | Description |
---|---|---|
value | T | The value to compare. |
Returns
boolean
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:703
containsErr
▸ containsErr(error
): boolean
Returns true
if the result is an Err
and the given error strict equals it.
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
Parameters
Name | Type | Description |
---|---|---|
error | E | The error to compare. |
Returns
boolean
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:727
eq
▸ eq(other
): boolean
Checks whether or not other
equals with self.
See
https://doc.rust-lang.org/std/cmp/trait.PartialEq.html#tymethod.eq
Parameters
Name | Type | Description |
---|---|---|
other | Result <T , E > | The other result to compare. |
Returns
boolean
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:805
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.
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
Returns
Option
<E
>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:139
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
.
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
Parameters
Name | Type | Description |
---|---|---|
message | string | The message for the error. |
Returns
T
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:419
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
.
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
Parameters
Name | Type | Description |
---|---|---|
message | string | The message for the error. |
Returns
E
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:444
flatten
▸ flatten<IT
>(this
): Result
<IT
, E
>
Converts from Result<Result<T, E>, E>
to Result<T, 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
Type parameters
Name |
---|
IT |
Parameters
Name | Type |
---|---|
this | Result <Result <IT , E >, E > |
Returns
Result
<IT
, E
>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:766
inspect
▸ inspect(cb
): IResult
<T
, E
>
Calls the provided closure with a reference to the contained value (if Ok
).
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
Parameters
Name | Type | Description |
---|---|---|
cb | (value : T ) => void | The predicate. |
Returns
IResult
<T
, E
>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:308
inspectAsync
▸ inspectAsync(cb
): Promise
<IResult
<T
, E
>>
Calls the provided closure with a reference to the contained value (if Ok
) and awaits it.
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
Parameters
Name | Type | Description |
---|---|---|
cb | (value : T ) => Awaitable <void > | The predicate. |
Returns
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:328
inspectErr
▸ inspectErr(cb
): IResult
<T
, E
>
Calls the provided closure with a reference to the contained error (if Err
).
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
Parameters
Name | Type | Description |
---|---|---|
cb | (error : E ) => void | The predicate. |
Returns
IResult
<T
, E
>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:348
inspectErrAsync
▸ inspectErrAsync(cb
): Promise
<IResult
<T
, E
>>
Calls the provided closure with a reference to the contained error (if Err
) and awaits it.
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
Parameters
Name | Type | Description |
---|---|---|
cb | (error : E ) => Awaitable <void > | The predicate. |
Returns
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:368
intoOkOrErr
▸ intoOkOrErr(): T
| E
Returns the Ok
value if self is Ok
, and the Err
value if self is Err
.
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
Returns
T
| E
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:784
intoPromise
▸ intoPromise(): Promise
<Result
<Awaited
<T
>, Awaited
<E
>>>
Returns a Promise
object with the awaited value (if Ok
) or the awaited error (if Err
).
Example
let x = ok(Promise.resolve(3));
assert.equal(await x.intoPromise(), ok(3));
Note
This is an extension not supported in Rust
Returns
Promise
<Result
<Awaited
<T
>, Awaited
<E
>>>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:797
isErr
▸ isErr(): this is Err<E>
Returns true
if the result is Err
.
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
Returns
this is Err<E>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:75
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.
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
Type parameters
Name | Type |
---|---|
R | extends boolean |
Parameters
Name | Type | Description |
---|---|---|
cb | (error : E ) => R | The predicate. |
Returns
this is Err<E> & R
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:99
isOk
▸ isOk(): this is Ok<T>
Returns true
if the result is Ok
.
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
Returns
this is Ok<T>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:34
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.
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
Type parameters
Name | Type |
---|---|
R | extends boolean |
Parameters
Name | Type |
---|---|
cb | (value : T ) => R |
Returns
this is Ok<T> & R
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:57
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.
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
Returns
Generator
<T
, any
, unknown
>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:394
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.
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
Type parameters
Name |
---|
U |
Parameters
Name | Type | Description |
---|---|---|
cb | (value : T ) => U | The predicate. |
Returns
Result
<U
, E
>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:159
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.
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
Type parameters
Name |
---|
F |
Parameters
Name | Type | Description |
---|---|---|
cb | (error : E ) => F | The predicate. |
Returns
Result
<T
, F
>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:258
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.
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
Type parameters
Name |
---|
IT |
IE |
Parameters
Name | Type | Description |
---|---|---|
cb | (error : E ) => Result <IT , IE > | The predicate. |
Returns
Result
<T
| IT
, IE
>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:288
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.
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
Type parameters
Name |
---|
IT |
IE |
Parameters
Name | Type | Description |
---|---|---|
cb | (value : T ) => Result <IT , IE > | The predicate. |
Returns
Result
<IT
, E
| IE
>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:190
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.
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
Type parameters
Name |
---|
U |
Parameters
Name | Type | Description |
---|---|---|
defaultValue | U | The default value to use. |
cb | (value : T ) => U | The predicate. |
Returns
U
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:213
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.
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
Type parameters
Name |
---|
U |
Parameters
Name | Type | Description |
---|---|---|
op | (error : E ) => U | The predicate that is run on Err . |
cb | (value : T ) => U | The predicate that is run on Ok . |
Returns
U
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:236
match
▸ match<OkValue
, ErrValue
>(branches
): OkValue
| ErrValue
Runs ok
function if self is Ok
, otherwise runs err
function.
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);
Type parameters
Name |
---|
OkValue |
ErrValue |
Parameters
Name | Type | Description |
---|---|---|
branches | Object | The branches to match. |
branches.err | (error : E ) => ErrValue | - |
branches.ok | (value : T ) => OkValue | - |
Returns
OkValue
| ErrValue
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:836
ne
▸ ne(other
): boolean
Checks whether or not other
doesn't equal with self.
See
https://doc.rust-lang.org/std/cmp/trait.PartialEq.html#method.ne
Parameters
Name | Type | Description |
---|---|---|
other | Result <T , E > | The other result to compare. |
Returns
boolean
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:813
ok
▸ ok(): Option
<T
>
Converts from Result<T, E>
to Option<T>
.
Converts itself into an Option<T>
, and discarding the error, if any.
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
Returns
Option
<T
>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:119
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.
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
Type parameters
Name |
---|
F |
Parameters
Name | Type | Description |
---|---|---|
result | Result <T , F > | The result to check. |
Returns
Result
<T
, F
>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:658
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.
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
Type parameters
Name |
---|
F |
Parameters
Name | Type | Description |
---|---|---|
cb | (error : E ) => Result <T , F > | The predicate. |
Returns
Result
<T
, F
>
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:679
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))
.
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
Type parameters
Name |
---|
IT |
Parameters
Name | Type |
---|---|
this | Result <Option <IT >, E > |
Returns
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:743
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
.
Seealso
Seealso
Seealso
Seealso
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
Returns
T
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:472
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
.
Seealso
Seealso
Seealso
Seealso
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
Returns
E
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:500
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.
Seealso
Seealso
Seealso
Seealso
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
Type parameters
Name |
---|
V |
Parameters
Name | Type | Description |
---|---|---|
defaultValue | V | The default value. |
Returns
T
| V
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:527
unwrapOrElse
▸ unwrapOrElse<V
>(op
): T
| V
Returns the contained Ok
value or computes it from a closure.
Seealso
Seealso
Seealso
Seealso
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
Type parameters
Name |
---|
V |
Parameters
Name | Type | Description |
---|---|---|
op | (error : E ) => V | The predicate. |
Returns
T
| V
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:548
unwrapRaw
▸ unwrapRaw(): T
Returns the contained Ok
value.
If the value is an Err
, it throws the contained error.
Seealso
Seealso
Seealso
Seealso
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'
});
Returns
T
Defined in
projects/utilities/packages/result/src/lib/Result/IResult.ts:574