quite-possibly 1.1.0 | Documentation

quite-possibly

1.1.0

Option ▸
- Static members
- .from
- .none
- Instance members
- #unwrap
- #unwrapOr
- #unwrapOrElse
- #map
- #then
- #or
- #orElse
- #isSome
- #isNone
Result ▸
- Static members
- .ok
- .error
- .wrap
- .createFnWrapper
- .wrapFn
- .wrapPromise
- Instance members
- #unwrap
- #unwrapOr
- #unwrapOrElse
- #ok
- #err
- #map
- #mapErr
- #then
- #or
- #orElse
- #isError
- #isValue

Need help reading this?

Option

src/option.ts

A wrapper that warps a value of type T, that can either be a value or some, or none

new Option()

Static Members

▸ from(value?)

src/option.ts

Wrap a JS value in and Option

from(value: (T | null)?): Option<T>

Parameters

value ((T | null)?) That value that you want to wrap in an option

Returns

Option<T>: The option representation of the value

▸ none()

src/option.ts

Construct a new None

none(): Option<T>

Returns

Option<T>: A new none

Instance Members

▸ unwrap()

src/option.ts

Get access to the underling value

unwrap(): T

Returns

T

Throws

NoneValueError: if the options is none

▸ unwrapOr(defaultValue)

src/option.ts

Safely unwrap an option, with a default value

unwrapOr(defaultValue: T): T

Parameters

defaultValue (T) The value to be used in the case that the option is None, if this is expensive, please use unwrapOrElse for lazy computation

Returns

T

▸ unwrapOrElse(defaultFn)

src/option.ts

Safely unwrap an option, with a function that returns the default value

unwrapOrElse(defaultFn: function (): T): T

Parameters

defaultFn (function (): T) A function to be called incas of None

Returns

T

▸ map(fn)

src/option.ts

Map a some value to a different some value

map(fn: function (val: T): U): Option

Parameters

fn (function (val: T): U) The function to be called

Returns

Option

▸ then(fn)

src/option.ts

Map a some value to either a None or a new Some value that might have a different type

then(fn: function (val: T): Option): Option

Parameters

fn (function (val: T): Option) The mapping function

Returns

Option

▸ or(value, fn)

src/option.ts

Map a None to either a None or a new Some value that might have a different type

or(value: Option<T>, fn: any): Option<T>

Parameters

value (Option<T>)

fn (any) The mapping function

Returns

Option<T>

▸ orElse(fn)

src/option.ts

Map a None to either a None or a new Some value that might have a different type

orElse(fn: function (): Option<T>): Option<T>

Parameters

fn (function (): Option<T>) The mapping function

Returns

Option<T>

▸ isSome()

src/option.ts

Returns true if is some

isSome(): boolean

Returns

boolean

▸ isNone()

src/option.ts

Returns true if is none

isNone(): boolean

Returns

boolean

Result

src/result.ts

A wrapper that represents either a value of type T or an error of type E

new Result()

Static Members

▸ ok(val)

src/result.ts

Wrap val in Ok

ok(val: T): Result<T, E>

Parameters

val (T)

Returns

Result<T, E>

▸ error(val)

src/result.ts

Wrap val in Err

error(val: E): Result<T, E>

Parameters

val (E)

Returns

Result<T, E>

▸ wrap(fn)

src/result.ts

Run a function catching any errors and wrapping them in a result

wrap(fn: function (): T): Result<T, E>

Parameters

fn (function (): T) the function that you'd like to catch any errors from

Returns

Result<T, E>

▸ createFnWrapper()

src/result.ts

Create a function that can wrap any other function that returns T in a Result<T, E>

createFnWrapper()

▸ wrapFn(fn)

src/result.ts

Wrap a function so that it returns a Result<T, E> instead of throwing an error. If you only want to specify E, use createFnWrapper to generate a function wrapper first

wrapFn(fn: function (...args: Args): T): function (...args: Args): Result<T, E>

Parameters

fn (function (...args: Args): T) the function you want to wrap

Returns

function (...args: Args): Result<T, E>

▸ wrapPromise(fn)

src/result.ts

Like the wrap function but takes an async function or a promise as input and returns a Result wrapped in a promise

wrapPromise(fn: (function (): Promise<T> | Promise<T>)): Promise<Result<T, E>>

Parameters

fn ((function (): Promise<T> | Promise<T>)) The promise or async function you want to wrap

Returns

Promise<Result<T, E>>

Instance Members

▸ unwrap()

src/result.ts

Unwrap the underling result.

unwrap(): T

Returns

T

Throws

any: The error value if present

▸ unwrapOr(value)

src/result.ts

Attempt to get the underling value, but if there is an error, return the default value. If this computation is expensive, use unwrapOrElse for lazy evaluation instead

unwrapOr(value: T): T

Parameters

value (T) The default value to use incas of an error

Returns

T

▸ unwrapOrElse(fn)

src/result.ts

Attempt to get the underling value, but if there is an error, return the error

unwrapOrElse(fn: function (error: E): T): T

Parameters

fn (function (error: E): T) The function to call to get the value, error is the default value

Returns

T

▸ ok()

src/result.ts

If there is a value, return Some, if there is an error return None

ok(): Option<T>

Returns

Option<T>

▸ err()

src/result.ts

If there is a error, return Some, if there is an value return None

err(): Option<E>

Returns

Option<E>

▸ map(fn)

src/result.ts

Map a value to a another value

map(fn: function (value: T): U): Result<U, E>

Parameters

fn (function (value: T): U) The function to transform a value of type T to a value of type U

Returns

Result<U, E>

▸ mapErr(fn)

src/result.ts

Map an error to another error

mapErr(fn: function (error: E): U): Result<T, U>

Parameters

fn (function (error: E): U) The function to transform an error of type E to a error of type U

Returns

Result<T, U>

▸ then(fn)

src/result.ts

Map a value to a new result

then(fn: function (value: T): Result<U, E>): Result<U, E>

Parameters

fn (function (value: T): Result<U, E>) The function to transform a value of type T to a result of type Result<U, E>

Returns

Result<U, E>

▸ or(value, fn)

src/result.ts

Map an error to a new result

or(value: Result<T, U>, fn: any): Result<T, U>

Parameters

value (Result<T, U>)

fn (any) The function to transform a value of type T to a result of type Result<U, E>

Returns

Result<T, U>

▸ orElse(fn)

src/result.ts

Map an error to a new result

orElse(fn: function (error: E): Result<T, U>): Result<T, U>

Parameters

fn (function (error: E): Result<T, U>) The function to transform a value of type T to a result of type Result<U, E>

Returns

Result<T, U>

▸ isError()

src/result.ts

Returns weather or not the object is an error

isError(): boolean

Returns

boolean

▸ isValue()

src/result.ts

Returns weather or not the object is a value

isValue(): boolean

Returns

boolean