Option

Index

Accessor

• getOrElse
• getOrThrow

Constructor

• from
• Some

Type

• isNone
• isSome

Other

• None
• Some
• None
• andThen
• map
• orElse

Accessor

getOrElse

• getOrElse<Value, DefaultValue>(self, getDefaultValue): Value | DefaultValue

• Returns the value if Some, getDefaultValue() if None.

  const x = Some('foo');
  Option.getOrElse(x, () => 'bar');// 'foo'
  
  const x = None;
  Option.getOrElse(x, () => 'bar');// 'bar'

getOrThrow

• getOrThrow<Value>(self): Value

• Returns the value if Some, throw an error if None

  ⚠ Impure function that may throw an error, its use is generally discouraged.

  let x = Some('foo');
  Option.getOrThrow(x);// 'foo'
  
  let x = None;
  Option.getOrThrow(x);// throw TypeError('option must not be a null|undefined')

Constructor

from

• from<Value>(value): Option<Exclude<Value, NullableValues>>

• Try to coerce value to Option

  Option.from(null);// undefined
  Option.from(undefined);// undefined
  Option.from('foo');// 'foo'

Some

• Some<Value>(value): Option<Value>

• An identity function that validates passed value

Type

isNone

• isNone(anyValue): anyValue is OptionLike<never>

• Return true if anyValue is nullor undefined

  Option.isNone(None);// true
  Option.isNone(undefined);// true
  Option.isNone(null);// true
  
  Option.isNone(Some('foo'));// false
  Option.isNone('foo');// false

isSome

• isSome<Value>(anyValue): anyValue is Exclude<Value, OptionLike<never>>

• Return true if anyValue is neither null nor undefined

  Option.isSome(Option.None);// false
  Option.isSome(undefined);// false
  Option.isSome(null);// false
  
  Option.isSome(Option.Some('foo'));// true
  Option.isSome('foo');// true

Other

None

None: undefined

Alias for undefined

Some

Some<Value>: Value extends Nullable ? never : Value

Non null and non undefined value

---

Type parameters

• Value

None

None: undefined

andThen

• andThen<ValueFrom, ValueTo>(self, fn): Option<ValueTo>

• Returns Option.None if the option is Option.None, otherwise calls fn with the value and returns the result. Some languages call this operation flatMap or chain.

  const square = (x: number): Option<number> => Option.Some(x * x);
  
  Option.andThen(Option.Some(2), square); // Option.Some(16)
  Option.andThen(Option.None, square); // Option.None

map

• map<ValueFrom, ValueTo>(self, fn): Option<ValueTo>

• Maps a Option<Value> to Option<U> by applying a function to a contained Some value, leaving a None value untouched. This function can be used to compose the results of two functions.

  const x = Some('foo');
  Option.map(x, (value) => `${value}_bar`));// Some('foo_bar') == 'foo_bar'

orElse

• orElse<ValueFrom>(self, fn): Option<ValueFrom>

• Returns the option if it contains a value, otherwise calls fn and returns the result.

  const alt = () => Some('bar')
  
  Option.orElse(Option.Some('foo'), alt); // Option.Some('foo')
  Option.orElse(Option.None, alt); // Option.Some('bar')