Std.List

97 public declarations

• all&Array[T] -> fn(T) -> Bool -> Bool

  Whether every element satisfies the predicate. True for an empty array.

  fn
• any&Array[T] -> fn(T) -> Bool -> Bool

  Whether any element satisfies the predicate. False for an empty array.

  fn
• breakWhen&Array[T] -> fn(T) -> Bool -> (Array[T], Array[T])

  The longest leading run the predicate *rejects*, and the rest.

  fn
• cartesian&Array[A] -> &Array[B] -> Array[(A, B)]

  Every pairing of one array's elements with the other's.

  fn
• chunksOf&Array[T] -> Int -> Array[Array[T]]

  The array in pieces of at most `size` elements.

  fn
• concat&Array[T] -> &Array[T] -> Array[T]

  One array followed by another.

  fn
• contains&Array[T] -> T -> Bool

  Whether any element equals the given value.

  fn
• count&Array[T] -> T -> Int

  How many elements equal the given value.

  fn
• countWhere&Array[T] -> fn(T) -> Bool -> Int

  How many elements the predicate accepts.

  fn
• cycle&Array[T] -> Int -> Array[T]

  The array repeated end to end a number of times.

  fn
• difference&Array[T] -> &Array[T] -> Array[T]

  Every element of the first array that is not in the second.

  fn
• distinct&Array[T] -> Array[T]

  The elements with later duplicates removed, keeping the first of each.

  fn
• distinctBy&Array[T] -> fn(T, T) -> Bool -> Array[T]

  The elements with later duplicates removed under a comparison.

  fn
• drop&Array[T] -> Int -> Array[T]

  Every element after the first `skipped`.

  fn
• dropEnd&Array[T] -> Int -> Array[T]

  Every element but the last `skipped`.

  fn
• dropWhile&Array[T] -> fn(T) -> Bool -> Array[T]

  Everything after the longest leading run the predicate accepts.

  fn
• dropWhileEnd&Array[T] -> fn(T) -> Bool -> Array[T]

  The array with trailing elements the predicate accepts removed.

  fn
• enumerate&Array[T] -> Array[(Int, T)]

  Every element paired with its position.

  fn
• filter&Array[T] -> fn(T) -> Bool -> Array[T]

  Every element the predicate accepts.

  fn
• find&Array[T] -> fn(T) -> Bool -> Option[T]

  The first element the predicate accepts, or `None`.

  fn
• findIndex&Array[T] -> fn(T) -> Bool -> Option[Int]

  The position of the first element the predicate accepts, or `None`.

  fn
• findIndices&Array[T] -> fn(T) -> Bool -> Array[Int]

  Every position whose element the predicate accepts.

  fn
• first&Array[T] -> Option[T]

  The first element, or `None` for an empty array.

  fn
• flatMap&Array[A] -> fn(A) -> Array[B] -> Array[B]

  Every element transformed into an array, and those arrays joined.

  fn
• flatten&Array[Array[T]] -> Array[T]

  Every array joined end to end.

  fn
• fold&Array[T] -> fn(A, T) -> A -> A -> A

  Combine every element into one, left to right.

  fn
• foldRight&Array[T] -> fn(T, A) -> A -> A -> A

  Combine every element into one, right to left.

  fn
• get&Array[T] -> Int -> Option[T]

  The element at a position, or `None` when there is none.

  fn
• group&Array[T] -> Array[Array[T]]

  Runs of adjacent equal elements.

  fn
• groupBy&Array[T] -> fn(T, T) -> Bool -> Array[Array[T]]

  Runs of adjacent elements that a comparison calls equivalent.

  fn
• indexOf&Array[T] -> T -> Option[Int]

  The position of the first element equal to the given value.

  fn
• indicesOf&Array[T] -> T -> Array[Int]

  Every position holding the given value.

  fn
• initial&Array[T] -> Array[T]

  Every element but the last, or an empty array when there is none.

  fn
• insertBy&Array[T] -> T -> fn(T, T) -> Bool -> Array[T]

  A value placed into an array ordered by a comparison, keeping it in order.

  fn
• insertOrdered&Array[T] -> T -> Array[T] where T: Ord

  A value placed into an array that is already in ascending order, keeping it

  fn
• intercalate&Array[Array[T]] -> &Array[T] -> Array[T]

  Every array joined with a separator array between them.

  fn
• intersection&Array[T] -> &Array[T] -> Array[T]

  Every element of the first array that is also in the second.

  fn
• intersperse&Array[T] -> T -> Array[T]

  A separator placed between every pair of elements.

  fn
• isEmpty&Array[T] -> Bool

  Whether the array has no elements.

  fn
• isInfixOf&Array[T] -> &Array[T] -> Bool

  Whether one array appears inside another as a contiguous run.

  fn
• isPrefixOf&Array[T] -> &Array[T] -> Bool

  Whether one array begins with another.

  fn
• isSuffixOf&Array[T] -> &Array[T] -> Bool

  Whether one array ends with another.

  fn
• iterateInt -> T -> fn(T) -> T -> Array[T]

  Repeated application of a function, starting from a seed.

  fn
• last&Array[T] -> Option[T]

  The last element, or `None` for an empty array.

  fn
• length&Array[T] -> Int

  The number of elements.

  fn
• lookup&Array[(K, V)] -> K -> Option[V]

  The value paired with the first matching key, or `None`.

  fn
• map&Array[A] -> fn(A) -> B -> Array[B]

  Every element transformed.

  fn
• mapAccum&Array[T] -> fn(A, T) -> (A, B) -> A -> (A, Array[B])

  A fold that also collects what each step produced, left to right.

  fn
• maximum&Array[T] -> Option[T] where T: Ord

  The largest element, or `None` for an empty array.

  fn
• maximumBy&Array[T] -> fn(T, T) -> Bool -> Option[T]

  The element a comparison ranks last, or `None` for an empty array.

  fn
• maximumOn&Array[T] -> fn(T) -> K -> Option[T] where K: Ord

  The element whose key is largest, or `None` for an empty array.

  fn
• merge&Array[T] -> &Array[T] -> Array[T] where T: Ord

  Two ascending arrays interleaved into one.

  fn
• mergeBy&Array[T] -> &Array[T] -> fn(T, T) -> Bool -> Array[T]

  Two arrays ordered by the same comparison interleaved into one.

  fn
• minimum&Array[T] -> Option[T] where T: Ord

  The smallest element, or `None` for an empty array.

  fn
• minimumBy&Array[T] -> fn(T, T) -> Bool -> Option[T]

  The element a comparison ranks first, or `None` for an empty array.

  fn
• minimumOn&Array[T] -> fn(T) -> K -> Option[T] where K: Ord

  The element whose key is smallest, or `None` for an empty array.

  fn
• modify&Array[T] -> Int -> fn(T) -> T -> Array[T]

  The array with one position transformed, or unchanged when it has none.

  fn
• notContains&Array[T] -> T -> Bool

  Whether no element equals the given value.

  fn
• partition&Array[T] -> fn(T) -> Bool -> (Array[T], Array[T])

  The elements the predicate accepts, and the elements it rejects.

  fn
• permutations&Array[T] -> Array[Array[T]]

  Every ordering of the elements. The count is the factorial of the length,

  fn
• pick&Array[T] -> &Array[Int] -> Array[T]

  The elements at the given positions, skipping positions the array lacks.

  fn
• prefixes&Array[T] -> Array[Array[T]]

  Every prefix, shortest first, including the empty one and the whole array.

  fn
• product&Array[T] -> Option[T] where T: One + Mul

  The product of every element, or `None` for an empty array.

  fn
• productOr&Array[T] -> T -> T where T: One + Mul

  Every element multiplied together, with a caller-supplied value for empty.

  fn
• rangeInt -> Int -> Array[Int]

  The whole numbers from `from` up to but not including `to`.

  fn
• removeFirst&Array[T] -> T -> Array[T]

  The first occurrence of a value removed, if it is there.

  fn
• replicateInt -> T -> Array[T]

  A value repeated a number of times. A count below one produces nothing.

  fn
• rest&Array[T] -> Array[T]

  Every element but the first, or an empty array when there is none.

  fn
• reversed&Array[T] -> Array[T]

  The elements in reverse order.

  fn
• scan&Array[T] -> fn(A, T) -> A -> A -> Array[A]

  Every running total, starting from the initial value.

  fn
• scanRight&Array[T] -> fn(T, A) -> A -> A -> Array[A]

  Every running total, from the right.

  fn
• set&Array[T] -> Int -> T -> Array[T]

  The array with one position replaced, or unchanged when it has none.

  fn
• slice&Array[T] -> Int -> Int -> Array[T]

  The elements from `from` up to but not including `to`.

  fn
• sortBy&Array[T] -> fn(T, T) -> Bool -> Array[T]

  The elements ordered by a comparison the caller supplies.

  fn
• sorted&Array[T] -> Array[T] where T: Ord

  The elements in ascending order, under the type's own ordering.

  fn
• sortOn&Array[T] -> fn(T) -> K -> Array[T] where K: Ord

  The elements ordered by a key drawn from each one.

  fn
• span&Array[T] -> fn(T) -> Bool -> (Array[T], Array[T])

  The longest leading run the predicate accepts, and the rest.

  fn
• splitAt&Array[T] -> Int -> (Array[T], Array[T])

  The array split at a position: the first `at` elements, then the rest.

  fn
• stripPrefix&Array[T] -> &Array[T] -> Option[Array[T]]

  The remainder after a prefix, or `None` when the prefix is not there.

  fn
• stripSuffix&Array[T] -> &Array[T] -> Option[Array[T]]

  The remainder before a suffix, or `None` when the suffix is not there.

  fn
• subsequences&Array[T] -> Array[Array[T]]

  Every subsequence, including the empty one and the whole array.

  fn
• suffixes&Array[T] -> Array[Array[T]]

  Every suffix, longest first, including the whole array and the empty one.

  fn
• sum&Array[T] -> Option[T] where T: Zero + Add

  The sum of every element, or `None` for an empty array.

  fn
• sumOr&Array[T] -> T -> T where T: Zero + Add

  Every element added together, with a caller-supplied value for empty.

  fn
• take&Array[T] -> Int -> Array[T]

  The first `wanted` elements, or every element when the array is shorter.

  fn
• takeEnd&Array[T] -> Int -> Array[T]

  The last `wanted` elements, or every element when the array is shorter.

  fn
• takeWhile&Array[T] -> fn(T) -> Bool -> Array[T]

  The longest leading run of elements the predicate accepts.

  fn
• transpose&Array[Array[T]] -> Array[Array[T]]

  The rows and columns exchanged. Rows of unequal length contribute only the

  fn
• unfoldInt -> S -> fn(S) -> Option[(T, S)] -> Array[T]

  An array grown from a seed until the step answers `None`.

  fn
• union&Array[T] -> &Array[T] -> Array[T]

  The first array followed by every element of the second it does not contain.

  fn
• unzip&Array[(A, B)] -> (Array[A], Array[B])

  Pairs separated back into two arrays.

  fn
• unzip3&Array[(A, B, C)] -> (Array[A], Array[B], Array[C])

  Triples separated back into three arrays.

  fn
• windows&Array[T] -> Int -> Array[Array[T]]

  Every contiguous run of `size` elements, one position apart.

  fn
• zip&Array[A] -> &Array[B] -> Array[(A, B)]

  Corresponding elements paired, stopping at the shorter array.

  fn
• zip3&Array[A] -> &Array[B] -> &Array[C] -> Array[(A, B, C)]

  Three arrays' corresponding elements gathered, stopping at the shortest.

  fn
• zipWith&Array[A] -> &Array[B] -> fn(A, B) -> C -> Array[C]

  Corresponding elements combined, stopping at the shorter array.

  fn
• zipWith3&Array[A] -> &Array[B] -> &Array[C] -> fn(A, B, C) -> D -> Array[D]

  Three arrays' corresponding elements combined, stopping at the shortest.

  fn