Interface TaskOutcome<T>

Base interface for all functype data structures. This provides a standard contract with core functional programming traits.

Example

// Implementing FunctypeBase for a custom data structure
class MyContainer<T> implements FunctypeBase<T, "Empty" | "Full"> {
  // Implementation of all required methods...
}

interface TaskOutcome<out T> {
 _meta: TaskMetadata;
 _tag: "Ok" | "Err";
 "[toStringTag]": string;
 ap: (ff: TaskOutcome<(value: T) => U>) => TaskOutcome;
 error?: Throwable;
 flatMap: (
 f: (value: T) => TaskOutcome | Either<Throwable, U>,
 ) => TaskOutcome;
 flatMapAsync: (
 f: (value: T) => Promise<TaskOutcome>,
 ) => Promise<TaskOutcome>;
 fold: (onErr: (error: Throwable) => U, onOk: (value: T) => U) => U;
 isErr: () => this is Err<T>;
 isFailure: () => this is Err<T>;
 isOk: () => this is Ok<T>;
 isSuccess: () => this is Ok<T>;
 map: (f: (value: T) => U) => TaskOutcome;
 mapAsync: (f: (value: T) => Promise) => Promise<TaskOutcome>;
 mapError: (f: (error: Throwable) => Throwable) => TaskOutcome<T>;
 match: (
 patterns: { Err: (error: Throwable) => U; Ok: (value: T) => U },
 ) => U;
 toEither: () => Either<Throwable, T>;
 toList: () => List<T>;
 toOption: () => Option<T>;
 toTry: () => Try<T>;
 value?: T;
 get isEmpty(): boolean;
 get size(): number;
 contains(value: unknown): boolean;
 count(p: (x: T) => boolean): number;
 doUnwrap(): DoResult<T>;
 exists(p: (a: T) => boolean): boolean;
 find(p: (a: T) => boolean): Option<T>;
 foldLeft(z: B): (op: (b: B, a: T) => B) => B;
 foldRight(z: B): (op: (a: T, b: B) => B) => B;
 forEach(f: (a: T) => void): void;
 or<T2 extends unknown>(alternative: Extractable<T2>): Extractable<T | T2>;
 orElse<T2 extends unknown>(defaultValue: T2): T | T2;
 orNull(): T | null;
 orThrow(error?: Error): T;
 orUndefined(): T | undefined;
 recover(value: U): Ok<T | U>;
 recoverWith(f: (error: Throwable) => U): Ok<T | U>;
 reduce(
 op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>,
 ): Widen<T, B>;
 reduceRight(
 op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>,
 ): Widen<T, B>;
 serialize(): SerializationMethods<T>;
 toPromise(): Promise<T>;
}

Type Parameters

out T
The type of value contained in the functor

Hierarchy (View Summary)

FunctypeBase<T, "Ok" | "Err">
Extractable<T>
AsyncMonad<T>
Promisable<T>
Doable<T>
- TaskOutcome
 - Ok
 - Err

Index

Properties

`Readonly`_meta

_meta: TaskMetadata

`Readonly`_tag

_tag: "Ok" | "Err"

`Readonly`[toStringTag]

"[toStringTag]": string

`Readonly`ap

ap: (ff: TaskOutcome<(value: T) => U>) => TaskOutcome

`Optional` `Readonly`error

error?: Throwable

`Readonly`flatMap

flatMap: (
f: (value: T) => TaskOutcome | Either<Throwable, U>,
) => TaskOutcome

`Readonly`flatMapAsync

flatMapAsync: (
f: (value: T) => Promise<TaskOutcome>,
) => Promise<TaskOutcome>

`Readonly`fold

fold: (onErr: (error: Throwable) => U, onOk: (value: T) => U) => U

`Readonly`isErr

isErr: () => this is Err<T>

`Readonly`isFailure

isFailure: () => this is Err<T>

`Readonly`isOk

isOk: () => this is Ok<T>

`Readonly`isSuccess

isSuccess: () => this is Ok<T>

`Readonly`map

map: (f: (value: T) => U) => TaskOutcome

`Readonly`mapAsync

mapAsync: (f: (value: T) => Promise) => Promise<TaskOutcome>

`Readonly`mapError

mapError: (f: (error: Throwable) => Throwable) => TaskOutcome<T>

`Readonly`match

match: (patterns: { Err: (error: Throwable) => U; Ok: (value: T) => U }) => U

`Readonly`toEither

toEither: () => Either<Throwable, T>

`Readonly`toList

toList: () => List<T>

`Readonly`toOption

toOption: () => Option<T>

`Readonly`toTry

toTry: () => Try<T>

`Optional` `Readonly`value

value?: T

Accessors

isEmpty

get isEmpty(): boolean
Returns boolean
Inherited from Traversable.isEmpty

size

get size(): number
Returns number
Inherited from Traversable.size

Methods

contains

contains(value: unknown): boolean
Parameters
- value: unknown
Returns boolean
Inherited from FunctypeBase.contains

count

count(p: (x: T) => boolean): number
Counts elements that satisfy the predicate. For single-value containers: returns 0 or 1 For collections: returns the count of matching elements
Parameters
- p: (x: T) => boolean
Returns number
Inherited from FunctypeBase.count

doUnwrap

doUnwrap(): DoResult<T>
Returns DoResult<T>
Inherited from Doable.doUnwrap

exists

exists(p: (a: T) => boolean): boolean
Tests whether any element satisfies the predicate. For single-value containers: tests the single value For collections: returns true if any element matches
Parameters
- p: (a: T) => boolean
Returns boolean
Inherited from FunctypeBase.exists

find

find(p: (a: T) => boolean): Option<T>
Finds the first element that satisfies the predicate. For single-value containers: returns Some(value) if predicate matches, None otherwise For collections: returns the first matching element wrapped in Option
Parameters
- p: (a: T) => boolean
Returns Option<T>
Inherited from FunctypeBase.find

foldLeft

foldLeft(z: B): (op: (b: B, a: T) => B) => B
Left-associative fold using the provided zero value and operation
Type Parameters
- B
Parameters
- z: B
 Zero/identity value
Returns (op: (b: B, a: T) => B) => B
A function that takes an operation to apply

Inherited from FunctypeBase.foldLeft

foldRight

foldRight(z: B): (op: (a: T, b: B) => B) => B
Right-associative fold using the provided zero value and operation
Type Parameters
- B
Parameters
- z: B
 Zero/identity value
Returns (op: (a: T, b: B) => B) => B
A function that takes an operation to apply

Inherited from FunctypeBase.foldRight

forEach

forEach(f: (a: T) => void): void
Applies an effect function to each element. For single-value containers: applies to the value if present For collections: applies to each element
Parameters
- f: (a: T) => void
Returns void
Inherited from FunctypeBase.forEach

or

or<T2 extends unknown>(alternative: Extractable<T2>): Extractable<T | T2>
Returns this container if it has a value, otherwise returns the alternative container. The alternative may carry a different type; the result widens to Extractable<T | T2>.
Type Parameters
- T2 extends unknown
Parameters
- alternative: Extractable<T2>
 The alternative container
Returns Extractable<T | T2>
This container or the alternative

Inherited from Extractable.or

orElse

orElse<T2 extends unknown>(defaultValue: T2): T | T2
Returns the contained value or a default value. The default may be of a different type; the result widens to T | T2.
Type Parameters
- T2 extends unknown
Parameters
- defaultValue: T2
 The value to return if extraction fails
Returns T | T2
The contained value or defaultValue

Inherited from Extractable.orElse

orNull

orNull(): T | null
Returns the contained value or null

Returns T | null
The contained value or null

Inherited from Extractable.orNull

orThrow

orThrow(error?: Error): T
Extract the value or throw an error
Parameters
- Optionalerror: Error
  Optional custom error to throw. If not provided, uses type-appropriate default error
Returns T
The contained value

Throws
The specified error, container's error, or a sensible default

Inherited from Extractable.orThrow

orUndefined

orUndefined(): T | undefined
Returns the contained value or undefined

Returns T | undefined
The contained value or undefined

Inherited from Extractable.orUndefined

recover

recover(value: U): Ok<T | U>
Type Parameters
- U extends unknown
Parameters
- value: U
Returns Ok<T | U>

recoverWith

recoverWith(f: (error: Throwable) => U): Ok<T | U>
Type Parameters
- U extends unknown
Parameters
- f: (error: Throwable) => U
Returns Ok<T | U>

reduce

reduce(op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>): Widen<T, B>
Type Parameters
- B = T
Parameters
- op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>
Returns Widen<T, B>
Inherited from FunctypeBase.reduce

reduceRight

reduceRight(
op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>,
): Widen<T, B>
Type Parameters
- B = T
Parameters
- op: (b: Widen<T, B>, a: Widen<T, B>) => Widen<T, B>
Returns Widen<T, B>
Inherited from FunctypeBase.reduceRight

serialize

serialize(): SerializationMethods<T>
Returns SerializationMethods<T>
Inherited from FunctypeBase.serialize

toPromise

toPromise(): Promise<T>
Converts this container to a Promise

The behavior depends on the implementing container:
- Success/Right/Some containers resolve with their value
- Failure/Left/None containers reject with their error/default error
Returns Promise<T>
A Promise that resolves or rejects based on the container's state

Inherited from Promisable.toPromise

Interface TaskOutcome<T>

Example

Type Parameters

Hierarchy (View Summary)

Index

Properties

Accessors

Methods

Properties

Readonly_meta

Readonly_tag

Readonly[toStringTag]

Readonlyap

Optional Readonlyerror

ReadonlyflatMap

ReadonlyflatMapAsync

Readonlyfold

ReadonlyisErr

ReadonlyisFailure

ReadonlyisOk

ReadonlyisSuccess

Readonlymap

ReadonlymapAsync

ReadonlymapError

Readonlymatch

ReadonlytoEither

ReadonlytoList

ReadonlytoOption

ReadonlytoTry

Optional Readonlyvalue

Accessors

isEmpty

Returns boolean

size

Returns number

Methods

contains

Parameters

Returns boolean

count

Parameters

Returns number

doUnwrap

Returns DoResult<T>

exists

Parameters

Returns boolean

find

Parameters

Returns Option<T>

foldLeft

Type Parameters

Parameters

Returns (op: (b: B, a: T) => B) => B

foldRight

Type Parameters

Parameters

Returns (op: (a: T, b: B) => B) => B

forEach

Parameters

Returns void

or

Type Parameters

Parameters

Returns Extractable<T | T2>

orElse

Type Parameters

Parameters

Returns T | T2

orNull

Returns T | null

orThrow

Parameters

Returns T

Throws

orUndefined

Returns T | undefined

recover

Type Parameters

Parameters

`Readonly`_meta

`Readonly`_tag

`Readonly`[toStringTag]

`Readonly`ap

`Optional` `Readonly`error

`Readonly`flatMap

`Readonly`flatMapAsync

`Readonly`fold

`Readonly`isErr

`Readonly`isFailure

`Readonly`isOk

`Readonly`isSuccess

`Readonly`map

`Readonly`mapAsync

`Readonly`mapError

`Readonly`match

`Readonly`toEither

`Readonly`toList

`Readonly`toOption

`Readonly`toTry

`Optional` `Readonly`value