List

Original: vector Mops package?

type List<T> = ()

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

public func clone<T>(list : List<T>) : List<T>

public func isEmpty(list : List<Any>) : Bool

public func size(list : List<Any>) : Bool

public func contains<T>(
  list : List<T>,
  element : T,
  equal : (T, T) -> Bool
) : Bool

public func containsAll<T>(
  list : List<T>,
  subList : List<T>,
  equal : (T, T) -> Bool
) : Bool

public func equal<T>(
  list1 : List<T>,
  list2 : List<T>,
  equal : (T, T) -> Bool
) : Bool

public func compare<T>(
  list1 : List<T>,
  list2 : List<T>,
  compare : (T, T) -> Order.Order
) : Order.Order

public func push<T>(list : List<T>, item : T) : ()

public func pop<T>(list : List<T>) : ?T

public func toText<T>(list : List<T>, f : T -> Text) : Text

public func hash<T>(list : List<T>, hash : T -> Nat32) : Nat32

public func indexOf<T>(
  list : List<T>,
  element : T,
  equal : (T, T) -> Bool
) : ?Nat

public func lastIndexOf<T>(
  list : List<T>,
  element : T,
  equal : (T, T) -> Bool
) : ?Nat

public func indexOfList<T>(
  list : List<T>,
  subList : List<T>,
  equal : (T, T) -> Bool
) : ?Nat

public func binarySearch<T>(
  list : List<T>,
  element : T,
  compare : (T, T) -> Order.Order
) : ?Nat

public func subList<T>(
  list : List<T>,
  start : Nat,
  length : Nat
) : List<T>

public func prefix<T>(list : List<T>, length : Nat) : List<T>

public func isPrefixOf<T>(
  list : List<T>,
  prefix : List<T>,
  equal : (T, T) -> Bool
) : Bool

public func isStrictPrefixOf<T>(
  list : List<T>,
  prefix : List<T>,
  equal : (T, T) -> Bool
) : Bool

public func suffix<T>(list : List<T>, length : Nat) : List<T>

public func isSuffixOf<T>(
  list : List<T>,
  suffix : List<T>,
  equal : (T, T) -> Bool
) : Bool

public func isStrictSuffixOf<T>(
  list : List<T>,
  suffix : List<T>,
  equal : (T, T) -> Bool
) : Bool

public func max<T>(list : List<T>, compare : (T, T) -> Order.Order) : ?T

public func min<T>(list : List<T>, compare : (T, T) -> Order.Order) : ?T

public func all<T>(list : List<T>, predicate : T -> Bool) : Bool

public func any<T>(list : List<T>, predicate : T -> Bool) : Bool

public func toArray<T>(list : List<T>) : [T]

public func toVarArray<T>(list : List<T>) : [var T]

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

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

public func values<T>(list : List<T>) : Iter.Iter<T>

public func fromIter<T>(iter : { next : () -> ?T }) : List<T>

public func trimToSize<T>(list : List<T>)

public func map<T1, T2>(list : List<T1>, f : T1 -> T2) : List<T2>

public func flatMap<T1, T2>(list : List<T1>, k : T1 -> Iter.Iter<T2>) : List<T2>

public func forEach<T>(list : List<T>, f : T -> ())

public func filterMap<T1, T2>(list : List<T1>, f : T1 -> ?T2) : List<T2>

public func mapEntries<T1, T2>(list : List<T1>, f : (Nat, T1) -> T2) : List<T2>

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

public func foldLeft<A, T>(
  list : List<T>,
  base : A,
  combine : (A, T) -> A
) : A

public func foldRight<T, A>(
  list : List<T>,
  base : A,
  combine : (T, A) -> A
) : A

public func first<T>(list : List<T>) : T

public func last<T>(list : List<T>) : T

public func singleton<T>(element : T) : List<T>

public func reverse<T>(list : List<T>)

public func merge<T>(
  list1 : List<T>,
  list2 : List<T>,
  compare : (T, T) -> Order.Order
) : List<T>

public func distinct<T>(list : List<T>, equal : (T, T) -> Bool) : List<T>

public func partition<T>(list : List<T>, predicate : T -> Bool) : (List<T>, List<T>)

public func split<T>(list : List<T>, index : Nat) : (List<T>, List<T>)

public func chunk<T>(list : List<T>, size : Nat) : List<List<T>>

public func flatten<T>(lists : Iter.Iter<List<T>>) : List<T>

public func zip<T1, T2>(list1 : List<T1>, list2 : List<T2>) : List<(T1, T2)>

public func zipWith<T1, T2, Z>(
  list1 : List<T1>,
  list2 : List<T2>,
  zip : (T1, T2) -> Z
) : List<Z>

public func filter<T>(list : List<T>, predicate : T -> Bool) : List<T>