Type Alias Stack<A>

Type declaration

• ap: function

  • ap<B extends unknown>(ff: Stack<(value: A) => B>): Stack<B>

    Applies a Stack of functions to this Stack

    Type Parameters

    • B extends unknown

    Parameters

    • ff: Stack<(value: A) => B>

      Stack of functions to apply

    Returns Stack<B>

    A new Stack with applied functions

• flatMap: function

  • flatMap<B extends unknown>(f: (a: A) => Stack<B>): Stack<B>

    Maps each element to a Stack and flattens the result

    Type Parameters

    • B extends unknown

    Parameters

    • f: (a: A) => Stack<B>

      The mapping function returning a Stack

    Returns Stack<B>

    A new flattened Stack

• flatMapAsync: function

  • flatMapAsync<B extends unknown>(
        f: (value: A) => PromiseLike<Stack<B>>,
    ): PromiseLike<Stack<B>>

    Maps each element to an async Stack and flattens the result

    Type Parameters

    • B extends unknown

    Parameters

    • f: (value: A) => PromiseLike<Stack<B>>

      The async mapping function returning a Stack

    Returns PromiseLike<Stack<B>>

    A promise of the new flattened Stack

• map: function

  • map<B extends unknown>(f: (a: A) => B): Stack<B>

    Transforms each element in the stack using the provided function

    Type Parameters

    • B extends unknown

    Parameters

    • f: (a: A) => B

      The mapping function

    Returns Stack<B>

    A new Stack with transformed elements

• match: function

  • match<R>(patterns: { Empty: () => R; NonEmpty: (values: A[]) => R }): R

    Pattern matches over the Stack, applying a handler function based on whether it's empty

    Type Parameters

    • R

    Parameters

    • patterns: { Empty: () => R; NonEmpty: (values: A[]) => R }

      Object with handler functions for Empty and NonEmpty variants

    Returns R

    The result of applying the matching handler function

• peek: function

  • peek(): Option<A>

    Return the top value without removing it

    Returns Option<A>

    The top value wrapped in an Option

• pop: function

  • pop(): [Stack<A>, Option<A>]

    Remove and return the top value from the stack

    Returns [Stack<A>, Option<A>]

    A tuple containing the new Stack and the value

• push: function

  • push(value: A): Stack<A>

    Push a value onto the top of the stack

    Parameters

    • value: A

      The value to push

    Returns Stack<A>

    A new Stack with the value added

• toArray: function

  • toArray(): A[]

    Convert the stack to an array

    Returns A[]

    An array of all elements

• toList: function

  • toList(): List<A>

    Convert the stack to a List

    Returns List<A>

    A List containing all elements

• toString: function

  • toString(): string

    Returns a string representation of the stack

    Returns string

    A string representation