Namespace Maybe

Index

Functions

Functions

map

map<T, U>(v: Maybe<T>, f: (v: T) => U): Voidable<U>

- Defined in maybe.ts:39
Map if there is a value, otherwise return undefined
Example
```
let a: 2 = map(1, v => v + 1)
let b: undefined = map(null, v => v + 1)
```
Type parameters
- T
- U
Parameters
- v: Maybe<T>
- f: (v: T) => U
  - - (v: T): U
    - Parameters
      - v: T
      Returns U
Returns Voidable<U>

mapOr

mapOr<T, U>(v: Maybe<T>, defv: DefaultOrFunc<U>, f: (v: T) => U): U

- Defined in maybe.ts:51
Map if there is a value, otherwise return default value
Example
```
let a: 2 = map(1, 3, v => v + 1)
let b: 3 = map(null, 3, v => v + 1)
```
Type parameters
- T
- U
Parameters
- v: Maybe<T>
- defv: DefaultOrFunc<U>
- f: (v: T) => U
  - - (v: T): U
    - Parameters
      - v: T
      Returns U
Returns U

okOr

okOr<T, E>(v: Maybe<T>, e: DefaultOrFunc<E>): Result<T, E>

- Defined in maybe.ts:58
If there is a value, pack it as ok, otherwise pack err * ```

Type parameters
- T
- E
Parameters
- v: Maybe<T>
- e: DefaultOrFunc<E>
Returns Result<T, E>

and

and<T, U>(v: Maybe<T>, other: Maybe<U>): Maybe<U>

- Defined in maybe.ts:64
Return undefined if the value is None, otherwise return other.

Type parameters
- T
- U
Parameters
- v: Maybe<T>
- other: Maybe<U>
Returns Maybe<U>

then

then<T, U>(v: Maybe<T>, f: (v: T) => Maybe<U>): Maybe<U>

- Defined in maybe.ts:70
Return undefined if the value is None, otherwise call f with the value and return the result

Type parameters
- T
- U
Parameters
- v: Maybe<T>
- f: (v: T) => Maybe<U>
  - - (v: T): Maybe<U>
    - Parameters
      - v: T
      Returns Maybe<U>
Returns Maybe<U>

or

or<T>(v: Maybe<T>, other: Maybe<T>): Maybe<T>

- Defined in maybe.ts:76
Return the value if the value is value, otherwise return other

Type parameters
- T
Parameters
- v: Maybe<T>
- other: Maybe<T>
Returns Maybe<T>

xor

xor<T>(v: Maybe<T>, other: Maybe<T>): Voidable<T>

- Defined in maybe.ts:82
return value if exactly one of v, other is value, otherwise return undefined

Type parameters
- T
Parameters
- v: Maybe<T>
- other: Maybe<T>
Returns Voidable<T>

transpose

transpose<T, E>(v?: Maybe<Result<T, E>>): Result<Voidable<T>, E>

- Defined in maybe.ts:89
Transpose to result

Type parameters
- T
- E
Parameters
- Optional v: Maybe<Result<T, E>>
Returns Result<Voidable<T>, E>

take

take<T>(v: Box<Maybe<T>>): Voidable<T>

- Defined in maybe.ts:95
Take the value, set the value in the box to undefined

Type parameters
- T
Parameters
- v: Box<Maybe<T>>
Returns Voidable<T>

replace

replace<T>(v: Box<Maybe<T>>, val: T): Maybe<T>

- Defined in maybe.ts:101
Replace the value in the box

Type parameters
- T
Parameters
- v: Box<Maybe<T>>
- val: T
Returns Maybe<T>

zip

zip<O>(...o: O): Voidable<{ [ I in keyof O]: O[I] extends Maybe<infer V> ? V : never }>

- Defined in maybe.ts:114
As long as any value in the tuple is None, return undefined
Example
```
let a: [1, 2, 3] = zip(1, 2, 3)
let b: undefined = zip(1, null, 3)
let c: undefined = zip(1, 2, undefined)
```
Type parameters
- O: unknown[]
Parameters
- Rest ...o: O
Returns Voidable<{ [ I in keyof O]: O[I] extends Maybe<infer V> ? V : never }>

Generated using TypeDoc