pure/Stack

Purely-functional, singly-linked lists.

type Stack<T> = ?(Stack<T>, T)

public func new<T>() : Stack<T>

public func isEmpty(stack : Stack<Any>) : Bool

public func size(stack : Stack<Any>) : Nat

public func contains<T>(stack : Stack<T>, item : T) : Bool

public func get<T>(stack : Stack<T>, n : Nat) : ?T

public func push<T>(stack : Stack<T>, item : T) : Stack<T>

public func last<T>(stack : Stack<T>) : ?T

public func pop<T>(stack : Stack<T>) : (?T, Stack<T>)

public func reverse<T>(stack : Stack<T>) : Stack<T>

public func forEach<T>(stack : Stack<T>, f : T -> ())

public func map<T1, T2>(stack : Stack<T1>, f : T1 -> T2) : Stack<T2>

public func filter<T>(stack : Stack<T>, f : T -> Bool) : Stack<T>

public func filterMap<T, U>(stack : Stack<T>, f : T -> ?U) : Stack<U>

public func mapResult<T, R, E>(stack : Stack<T>, f : T -> Result.Result<R, E>) : Result.Result<Stack<R>, E>

public func partition<T>(stack : Stack<T>, f : T -> Bool) : (Stack<T>, Stack<T>)

public func concat<T>(stack1 : Stack<T>, stack2 : Stack<T>) : Stack<T>

public func flatten<T>(stack : Iter.Iter<Stack<T>>) : Stack<T>

public func take<T>(stack : Stack<T>, n : Nat) : Stack<T>

public func drop<T>(stack : Stack<T>, n : Nat) : Stack<T>

public func foldLeft<T, A>(
  stack : Stack<T>,
  base : A,
  combine : (A, T) -> A
) : A

public func foldRight<T, A>(
  stack : Stack<T>,
  base : A,
  combine : (T, A) -> A
) : A

public func find<T>(stack : Stack<T>, f : T -> Bool) : ?T

public func all<T>(stack : Stack<T>, f : T -> Bool) : Bool

public func any<T>(stack : Stack<T>, f : T -> Bool) : Bool

public func merge<T>(
  stack1 : Stack<T>,
  stack2 : Stack<T>,
  lessThanOrEqual : (T, T) -> Bool
) : Stack<T>

public func compare<T>(
  stack1 : Stack<T>,
  stack2 : Stack<T>,
  compare : (T, T) -> Order.Order
) : Order.Order

public func equal<T>(
  stack1 : Stack<T>,
  stack2 : Stack<T>,
  equal : (T, T) -> Bool
) : Bool

public func generate<T>(n : Nat, f : Nat -> T) : Stack<T>

public func singleton<T>(item : T) : Stack<T>

public func repeat<T>(item : T, n : Nat) : Stack<T>

public func zip<T, U>(stack1 : Stack<T>, stack2 : Stack<U>) : Stack<(T, U)>

public func zipWith<T, U, V>(
  stack1 : Stack<T>,
  stack2 : Stack<U>,
  f : (T, U) -> V
) : Stack<V>

public func split<T>(stack : Stack<T>, n : Nat) : (Stack<T>, Stack<T>)

public func chunks<T>(stack : Stack<T>, n : Nat) : Stack<Stack<T>>

public func values<T>(stack : Stack<T>) : Iter.Iter<T>

public func fromArray<T>(array : [T]) : Stack<T>

public func fromVarArray<T>(array : [var T]) : Stack<T>

public func toArray<T>(stack : Stack<T>) : [T]

public func toVarArray<T>(stack : Stack<T>) : [var T]

public func fromIter<T>(iter : Iter.Iter<T>) : Stack<T>

public func toText<T>(stack : Stack<T>, f : T -> Text) : Text