Skip to main content

Interface: IOption<T>

Type parameters

Name
T

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 Some, otherwise none.

Returns

Generator<T, any, unknown>

Example

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

Example

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

See

Defined in

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


and

and<U>(option): Option<U>

Returns None if the option is None, otherwise returns option.

Type parameters

Name
U

Parameters

NameTypeDescription
optionOption<U>The option.

Returns

Option<U>

Example

const x: Option<number> = some(2);
const y: Option<string> = none;
assert.equal(x.and(y), none);

Example

const x: Option<number> = none;
const y: Option<string> = some('foo');
assert.equal(x.and(y), none);

Example

const x: Option<number> = some(2);
const y: Option<string> = some('foo');
assert.equal(x.and(y), some('foo'));

Example

const x: Option<number> = none;
const y: Option<string> = none;
assert.equal(x.and(y), none);

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.and

Defined in

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


andThen

andThen<U>(cb): Option<U>

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) => Option<U>The predicate.

Returns

Option<U>

Example

function fractionOf4(value: number) {
return value === 0 ? none : some(4 / value);
}

assert.equal(some(2).andThen(fractionOf4), some(4));
assert.equal(some(0).andThen(fractionOf4), none);
assert.equal(none.andThen(fractionOf4), none);

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:1338


contains

contains(value): boolean

Returns true if the option is a Some value containing the given value.

Parameters

NameTypeDescription
valueTThe value to compare.

Returns

boolean

Example

const x: Option<number> = some(2);
assert.equal(x.contains(2), true);

Example

const x: Option<number> = some(3);
assert.equal(x.contains(2), false);

Example

const x: Option<number> = none;
assert.equal(x.contains(2), false);

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.contains

Defined in

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


eq

eq(other): boolean

Checks whether or not other equals with self.

Parameters

NameTypeDescription
otherOption<T>The other option 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:1588


expect

expect(message): T

Returns the contained Some value.

Parameters

NameTypeDescription
messagestringThe message for the error. If the value is an Err, it throws an OptionError with the given message.

Returns

T

Example

const x: Option<string> = some(2);
assert.equal(x.expect('Whoops!'), 2);

Example

const x: Option<string> = none;
assert.throws(() => x.expect('Whoops!'), {
name: 'OptionError',
message: 'Whoops'
});

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.expect

Defined in

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


filter

filter(predicate): Option<T>

Returns None if the option is None, otherwise calls predicate with the wrapped value and returns:

  • Some(t) if predicate returns true (where t is the wrapped value), and
  • None if predicate returns false.

Parameters

NameTypeDescription
predicate(value: T) => booleanThe predicate.

Returns

Option<T>

Example

function isEven(value: number) {
return n % 2 === 0;
}

assert.equal(none.filter(isEven), none);
assert.equal(some(3).filter(isEven), none);
assert.equal(some(4).filter(isEven), some(4));

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.filter

Defined in

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


flatten

flatten<IT>(this): Option<IT>

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

Type parameters

Name
IT

Parameters

NameType
thisOption<Option<IT>>

Returns

Option<IT>

Example

const x: Option<Option<number>> = some(some(6));
assert.equal(x.flatten(), some(6));

Example

const x: Option<Option<number>> = some(none);
assert.equal(x.flatten(), none);

Example

const x: Option<Option<number>> = none;
assert.equal(x.flatten(), none);

See

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

Defined in

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


inspect

inspect(cb): this

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

Parameters

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

Returns

this

Seealso

inspectAsync for the awaitable version.

Example

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

Example

none.inspect(console.log);
// Doesn't log

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.inspect

Defined in

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


inspectAsync

inspectAsync(cb): Promise<IOption<T>>

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

Parameters

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

Returns

Promise<IOption<T>>

Seealso

inspect for the sync version.

Example

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

Example

await none.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:1221


intoPromise

intoPromise(): Promise<Option<Awaited<T>>>

Returns a Promise object with the awaited value (if Some).

Returns

Promise<Option<Awaited<T>>>

Example

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

Note

This is an extension not supported in Rust

Defined in

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


isNone

isNone(): this is None

Returns true if the option is a None value.

Returns

this is None

Example

const x: Option<number> = some(2);
assert.equal(x.isNone(), false);

Example

const x: Option<number> = none;
assert.equal(x.isNone(), true);

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.is_none

Defined in

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


isSome

isSome(): this is Some<T>

Returns true if the option is a Some value.

Returns

this is Some<T>

Example

const x: Option<number> = some(2);
assert.equal(x.isSome(), true);

Example

const x: Option<number> = none;
assert.equal(x.isSome(), false);

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.is_some

Defined in

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


isSomeAnd

isSomeAnd(cb): boolean

Returns true if the option is a Some and the value inside of it matches a predicate.

Parameters

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

Returns

boolean

Example

const x: Option<number> = some(2);
assert.equal(x.isSomeAnd((x) => x > 1), true);

Example

const x: Option<number> = some(0);
assert.equal(x.isSomeAnd((x) => x > 1), false);

Example

const x: Option<number> = none;
assert.equal(x.isSomeAnd((x) => x > 1), false);

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.is_some_and

Defined in

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


iter

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

Returns an iterator over the possibly contained value.

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

Returns

Generator<T, any, unknown>

Example

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

Example

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

See

Defined in

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


map

map<U>(cb): Option<U>

Maps an Option<T> to Option<U> by applying a function to a contained value.

Type parameters

Name
U

Parameters

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

Returns

Option<U>

Example

const maybeSomeString = some('Hello, world!');
const maybeSomeLength = maybeSomeString.map((value) => value.length);

assert.equal(maybeSomeLength, some(13));

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.map

Defined in

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


mapInto

mapInto<Inner>(cb): Option<Inner>

Maps a Some<T> to the returned Option<U> by applying a function to a contained value, leaving None untouched.

Type parameters

Name
Inner

Parameters

NameTypeDescription
cb(value: T) => Option<Inner>The predicate.

Returns

Option<Inner>

Example

const input: Option<string> = some('Hello, world!');
const result = input.mapInto((value) => some(value.length));

assert.equal(result, some(13));

Example

const input: Option<string> = none;
const result = input.mapInto((value) => some(value.length));

assert.equal(result, none);

Note

This is an extension not supported in Rust

Defined in

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


mapNoneInto

mapNoneInto<Inner>(cb): Option<T | Inner>

Maps a None to the returned Option<U> by applying a function to a contained value, leaving Some<T> untouched.

Type parameters

Name
Inner

Parameters

NameTypeDescription
cb() => Option<Inner>The predicate.

Returns

Option<T | Inner>

Example

const input: Option<string> = some('Hello, world!');
const result = input.mapNoneInto(() => some(13));

assert.equal(result, some('Hello, world!'));

Example

const input: Option<string> = none;
const result = input.mapNoneInto(() => some(13));

assert.equal(result, some(13));

Note

This is an extension not supported in Rust

Defined in

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


mapOr

mapOr<U>(defaultValue, cb): U

Returns the provided default result (if none), or applies a function to the contained value (if any).

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.
cb(value: T) => UThe predicate.

Returns

U

Example

const x: Option<string> = some('hello');
assert.equal(x.mapOr(42, (value) => value.length), 5);

Example

const x: Option<string> = none;
assert.equal(x.mapOr(42, (value) => value.length), 42);

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.map_or

Defined in

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


mapOrElse

mapOrElse<U>(defaultValue, cb): U

Computes a default function result (if none), or applies a different function to the contained value (if any).

Type parameters

Name
U

Parameters

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

Returns

U

Example

const x: Option<string> = some('hello');
assert.equal(x.mapOrElse(() => 42, (value) => value.length), 5);

Example

const x: Option<string> = none;
assert.equal(x.mapOrElse(() => 42, (value) => value.length), 42);

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.map_or_else

Defined in

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


match

match<SomeValue, NoneValue>(branches): SomeValue | NoneValue

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

Type parameters

Name
SomeValue
NoneValue

Parameters

NameTypeDescription
branchesObjectThe branches to match.
branches.none() => NoneValue-
branches.some(value: T) => SomeValue-

Returns

SomeValue | NoneValue

Example

const option = some(4).match({
some: (v) => v,
none: () => 0
});
assert.equal(option, 4);

Example

const option = none.match({
some: (v) => v,
none: () => 0
});
assert.equal(option, 0);

Defined in

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


ne

ne(other): boolean

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

Parameters

NameTypeDescription
otherOption<T>The other option 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:1595


okOr

okOr<E>(err): Result<T, E>

Transforms the Option<T> into a Result<T, E>, mapping Some(v) to Ok(v) and None to Err(err).

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

Type parameters

Name
E

Parameters

NameTypeDescription
errEThe error to be used.

Returns

Result<T, E>

Example

const x: Option<string> = some('hello');
assert.equal(x.okOr(0), ok('hello'));

Example

const x: Option<string> = none;
assert.equal(x.okOr(0), err(0));

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.ok_or

Defined in

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


okOrElse

okOrElse<E>(cb): Result<T, E>

Transforms the Option<T> into a Result<T, E>, mapping Some(v) to Ok(v) and None to Err(err()).

Type parameters

Name
E

Parameters

NameTypeDescription
cb() => EThe error to be used.

Returns

Result<T, E>

Example

const x: Option<string> = some('hello');
assert.equal(x.okOrElse(() => 0), ok('hello'));

Example

const x: Option<string> = none;
assert.equal(x.okOrElse(() => 0), err(0));

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.ok_or_else

Defined in

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


or

or(option): Option<T>

Returns the option if it contains a value, otherwise returns option.

Parameters

NameTypeDescription
optionOption<T>The option.

Returns

Option<T>

Example

const x: Option<number> = some(2);
const y: Option<number> = none;
assert.equal(x.or(y), some(2));

Example

const x: Option<number> = none;
const y: Option<number> = some(100);
assert.equal(x.or(y), some(100));

Example

const x: Option<number> = some(2);
const y: Option<number> = some(100);
assert.equal(x.or(y), some(2));

Example

const x: Option<number> = none;
const y: Option<number> = none;
assert.equal(x.or(y), none);

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.or

Defined in

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


orElse

orElse(cb): Option<T>

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.

Parameters

NameTypeDescription
cb() => Option<T>The predicate.

Returns

Option<T>

Example

const nobody = (): Option<string> => none;
const vikings = (): Option<string> => some('vikings');

assert.equal(some('barbarians').orElse(vikings), some('barbarians'));
assert.equal(none.orElse(vikings), some('vikings'));
assert.equal(none.orElse(nobody), none);

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.or_else

Defined in

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


transpose

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

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

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

Type parameters

Name
IT
E

Parameters

NameType
thisOption<Result<IT, E>>

Returns

Result<Option<IT>, E>

Example

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

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.transpose

Defined in

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


unwrap

unwrap(): T

Returns the contained Some value.

If the value is an Err, it throws an OptionError with the message.

Returns

T

Seealso

unwrapOr

Seealso

unwrapOrElse

Example

const x: Option<string> = some(2);
assert.equal(x.unwrap(), 2);

Example

const x: Option<string> = none;
assert.throws(() => x.unwrap(), {
name: 'OptionError',
message: 'Unwrap failed'
});

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.unwrap

Defined in

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


unwrapOr

unwrapOr<V>(defaultValue): T | V

Returns the contained Some value or a 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

NameType
defaultValueV

Returns

T | V

Example

assert.equal(some(2).unwrapOr(0), 2);

Example

assert.equal(none.unwrapOr(0), 0);

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.unwrap_or

Defined in

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


unwrapOrElse

unwrapOrElse<V>(cb): T | V

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

Type parameters

Name
V

Parameters

NameType
cb() => V

Returns

T | V

Example

assert.equal(some(2).unwrapOrElse(() => 0), 2);

Example

assert.equal(none.unwrapOrElse(() => 0), 0);

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.unwrap_or_else

Defined in

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


unzip

unzip<Inner, U>(this): [Option<Inner>, Option<U>]

Unzips an option containing a tuple of two options.

If self is Some((a, b)) this method returns [Some(a), Some(b)]. Otherwise, [None, None] is returned.

Type parameters

Name
Inner
U

Parameters

NameType
thisOption<readonly [Inner, U]>

Returns

[Option<Inner>, Option<U>]

Example

const x: Option<[number, string]> = some([1, 'hi']);
assert.equal(x.unzip(), [some(1), some('hi')]);

Example

const x: Option<[number, string]> = none;
assert.equal(x.unzip(), [none, none]);

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.unzip

Defined in

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


xor

xor(option): Option<T>

Returns Some if exactly one of self or option is Some, otherwise returns None.

Parameters

NameTypeDescription
optionOption<T>The option to compare.

Returns

Option<T>

Example

const x: Option<number> = some(2);
const y: Option<number> = none;
assert.equal(x.xor(y), some(2));

Example

const x: Option<number> = none;
const y: Option<number> = some(2);
assert.equal(x.xor(y), some(2));

Example

const x: Option<number> = some(2);
const y: Option<number> = some(2);
assert.equal(x.xor(y), none);

Example

const x: Option<number> = none;
const y: Option<number> = none;
assert.equal(x.xor(y), none);

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.xor

Defined in

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


zip

zip<U>(other): Option<[T, U]>

Zips self with another Option.

If self is Some(s) and other is Some(o), this method returns Some([s, o]). Otherwise, None is returned.

Type parameters

Name
U

Parameters

NameTypeDescription
otherOption<U>The option to zip self with.

Returns

Option<[T, U]>

Example

const x = some(1);
const y = some('hi');
const z = none;

assert.equal(x.zip(y), some([1, 'hi']));
assert.equal(x.zip(z), none);

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.zip

Defined in

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


zipWith

zipWith<U, R>(other, f): Option<R>

Zips self and another Option with function f.

If self is Some(s) and other is Some(o), this method returns Some(f(s, o)). Otherwise, None is returned.

Type parameters

Name
U
R

Parameters

NameTypeDescription
otherOption<U>The option to zip self with.
f(s: T, o: U) => RThe function that computes the returned value.

Returns

Option<R>

Example

class Point {
public readonly x: number;
public readonly y: number;

public constructor(x: number, y: number) {
this.x = x;
this.y = y;
}
}

const x = some(17.5);
const y = some(42.7);

assert.equal(x.zipWith(y, (s, o) => new Point(s, o)), some(new Point(17.5, 42.7)));
assert.equal(x.zipWith(none, (s, o) => new Point(s, o)), none);

See

https://doc.rust-lang.org/std/option/enum.Option.html#method.zip_with

Defined in

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