Nec
Enums
enum ViewRight[a: Type] with Eq
Sourcecase OneRight(a)
case SomeRight(Nec[a], a)
A datatype for pattern matching on a Nec (traversing right-to-left).
Definitions
def ap(f: Nec[a -> b \ ef], c: Nec[a]): Nec[b] \ ef
SourceApply every function from f
to every argument from x
and return a Nec with all results.
For f = f1, f2, ...
and x = x1, x2, ...
the results appear in the order
f1(x1), f1(x2), ..., f2(x1), f2(x2), ...
.
def append(c1: Nec[a], c2: Nec[a]): Nec[a]
SourceReturns a new Nec formed by appending the Necs c1
and c2
.
def count(f: a -> Bool \ ef, c: Nec[a]): Int32 \ ef
SourceReturns the number of elements in c
that satisfy the predicate f
.
def dropWhileLeft(f: a -> Bool \ ef, c: Nec[a]): List[a] \ ef
SourceReturns c
without the longest prefix that satisfies the predicate f
.
def dropWhileRight(f: a -> Bool \ ef, c: Nec[a]): List[a] \ ef
SourceReturns c
without the longest sufffix that satisfies the predicate f
.
def enumerator(rc: Region[r], c: Nec[a]): Iterator[(Int32, a), r, r] \ r
SourceReturns an iterator over c
zipped with the indices of the elements.
def exists(f: a -> Bool \ ef, c: Nec[a]): Bool \ ef
SourceReturns true
if and only if at least one element in c
satisfies the predicate f
.
Returns false
if c
is empty.
def filter(f: a -> Bool \ ef, c: Nec[a]): List[a] \ ef
SourceReturns a list of every element in c
that satisfies the predicate f
.
def filterMap(f: a -> Option[b] \ ef, c: Nec[a]): List[b] \ ef
SourceCollects the results of applying the partial function f
to every element in c
.
def findLeft(f: a -> Bool \ ef, c: Nec[a]): Option[a] \ ef
SourceOptionally returns the first element of c
that satisfies the predicate f
when searching from left to right.
def findMap(f: a -> Option[b] \ ef, c: Nec[a]): Option[b] \ ef
SourceReturns the first non-None result of applying the partial function f
to each element of c
.
Returns None
if f(c) for every element of c is None
.
def findRight(f: a -> Bool \ ef, c: Nec[a]): Option[a] \ ef
SourceOptionally returns the first element of c
that satisfies the predicate f
when searching from right to left.
def flatMap(f: a -> Nec[b] \ ef, c: Nec[a]): Nec[b] \ ef
SourceReturns the result of applying f
to every element in c
and concatenating the results.
def fold(l: Nec[a]): a
SourceReturns the result of applying combine
to all the elements in l
, using empty
as the initial value.
def foldLeft(f: b -> (a -> b \ ef), acc: b, c: Nec[a]): b \ ef
SourceApplies f
to a start value s
and all elements in c
going from left to right.
That is, the result is of the form: f(...f(f(s, x1), x2)..., xn)
.
def foldMap(f: a -> b \ ef, c: Nec[a]): b \ ef
SourceReturns the result of mapping each element and combining the results.
def foldRight(f: a -> (b -> b \ ef), s: b, c: Nec[a]): b \ ef
SourceApplies f
to a start value s
and all elements in c
going from right to left.
That is, the result is of the form: f(x1, ...f(xn-1, f(xn, s))...)
.
def foldRightWithCont(f: a -> ((Unit -> b \ ef) -> b \ ef), z: b, c: Nec[a]): b \ ef
SourceApplies f
to a start value z
and all elements in c
going from right to left.
That is, the result is of the form: f(x1, ...f(xn-1, f(xn, z))...)
.
A foldRightWithCont
allows early termination by not calling the continuation.
def forAll(f: a -> Bool \ ef, c: Nec[a]): Bool \ ef
SourceReturns true
if and only if all elements in c
satisfy the predicate f
.
Returns true
if c
is empty.
def forEachWithIndex(f: Int32 -> (a -> Unit \ ef), c: Nec[a]): Unit \ ef
SourceApplies f
to every element of c
along with that element's index.
def intersperse(sep: a, c: Nec[a]): Nec[a]
SourceReturns c
with a
inserted between every two adjacent elements.
def join(sep: String, c: Nec[a]): String
SourceReturns the concatenation of the string representation
of each element in c
with sep
inserted between each element.
def joinWith(f: a -> String \ ef, sep: String, c: Nec[a]): String \ ef
SourceReturns the concatenation of the string representation
of each element in c
according to f
with sep
inserted between each element.
def map(f: a -> b \ ef, c: Nec[a]): Nec[b] \ ef
SourceReturns the result of applying f
to every element in c
.
That is, the result is of the form: f(x1) :: f(x2) :: ...
.
def mapAccumLeft(f: s -> (a -> (s, b) \ ef), start: s, c: Nec[a]): (s, Nec[b]) \ ef
SourcemapAccumLeft
is a stateful version of map
. The accumulating parameter s
is updated at each
step in a left-to-right traversal.
def mapAccumRight(f: s -> (a -> (s, b) \ ef), start: s, c: Nec[a]): (s, Nec[b]) \ ef
SourcemapAccumRight
is a stateful version of map
. The accumulating parameter s
is updated at each
step in a right-to-left traversal.
def mapWithIndex(f: Int32 -> (a -> b \ ef), c: Nec[a]): Nec[b] \ ef
SourceReturns the result of applying f
to every element in c
along with that element's index.
That is, the result is of the form: f(x1, 0) :: f(x2, 1) :: ...
.
def maximumBy(cmp: a -> (a -> Comparison), c: Nec[a]): a
SourceFinds the largest element of c
according to the given comparator cmp
.
def minimumBy(cmp: a -> (a -> Comparison), c: Nec[a]): a
SourceFinds the smallest element of c
according to the given comparator cmp
.
def permutations(c: Nec[a]): Nec[List[a]]
SourceReturns all permutations of c
in lexicographical order by element indices in c
.
That is, c
is the first permutation and reverse(c)
is the last permutation.
def range(b: Int32, e: Int32): Option[Nec[Int32]]
SourceReturns a list of all integers between b
(inclusive) and e
(exclusive) wrapped in Some
.
Returns None
if b >= e
.
def reduce(c: Nec[a]): a
SourceApplies combine
to all elements in c
until a single value is obtained.
def reduceLeft(f: a -> (a -> a \ ef), c: Nec[a]): a \ ef
SourceApplies f
to all elements in c
going from left to right until a single value v
is obtained.
That is, the result is of the form: f(...f(f(x1, x2), x3)..., xn)
def reduceLeftTo(f: b -> (a -> b \ ef1), g: a -> b \ ef2, c: Nec[a]): b \ ef1 + ef2
SourceLeft-associative reduction of a structure.
Applies g
to the initial element of c
and combines it
with the remainder of c
using f
going from left to right.
def reduceRight(f: a -> (a -> a \ ef), c: Nec[a]): a \ ef
SourceApplies f
to all elements in c
going from right to left until a single value v
is obtained.
That is, the result is of the form: Some(f(x1, ...f(xn-2, f(xn-1, xn))...))
def reduceRightTo(f: a -> (b -> b \ ef1), g: a -> b \ ef2, c: Nec[a]): b \ ef1 + ef2
SourceRight-associative reduction of a structure.
Applies g
to the initial element of c
and combines it
with the remainder of c
using f
going from right to left.
def replace(from: { from = a }, to: { to = a }, l: Nec[a]): Nec[a]
SourceReturns l
with every occurrence of from
replaced by to
.
def sequence(c: Nec[m[a]]): m[Nec[a]]
SourceReturns the result of running all the actions in the Nec c
.
def shuffle(rnd: Random, c: Nec[a]): Option[Nec[a]] \ IO
SourceOptionally returns the Nec c
shuffled using the Fisher–Yates shuffle.
def sort(c: Nec[a]): Nec[a]
SourceSort Nec c
so that elements are ordered from low to high according to their Order
instance.
The sort is not stable, i.e., equal elements may appear in a different order than in the input c
.
The sort implementation is a Quicksort.
def sortBy(f: a -> b, c: Nec[a]): Nec[a]
SourceSort Nec c
so that elements are ordered from low to high according to the Order
instance
for the values obtained by applying f
to each element.
The sort is not stable, i.e., equal elements may appear in a different order than in the input c
.
The sort implementation is a Quicksort.
def sortWith(cmp: a -> (a -> Comparison), c: Nec[a]): Nec[a]
SourceSort Nec c
so that elements are ordered from low to high according to the comparison function cmp
.
The sort is not stable, i.e., equal elements may appear in a different order than in the input c
.
The sort implementation is a Quicksort.
def subsequences(c: Nec[a]): Nec[List[a]]
SourceReturns all subsequences of l
in lexicographical order by element indices in l
.
That is, l
is the first subsequence and Nil
is the last subsequence.
def sumWith(f: a -> Int32 \ ef, c: Nec[a]): Int32 \ ef
SourceReturns the sum of all elements in the Nec c
according to the function f
.
def takeWhileLeft(f: a -> Bool \ ef, c: Nec[a]): List[a] \ ef
SourceReturns the longest prefix of c
that satisfies the predicate f
.
def takeWhileRight(f: a -> Bool \ ef, c: Nec[a]): List[a] \ ef
SourceReturns the longest prefix of c
that satisfies the predicate f
.
def toMap(c: Nec[(a, b)]): Map[a, b]
SourceReturns the Nec of pairs c
that represents an association list as a map.
If c
contains multiple mappings with the same key, toMap
does not
make any guarantees about which mapping will be in the resulting map.
def toMapWith(f: a -> b, l: Nec[a]): Map[a, b]
SourceReturns a map with elements of l
as keys and f
applied as values.
If l
contains multiple mappings with the same key, toMapWith
does not
make any guarantees about which mapping will be in the resulting map.
def traverse(f: a -> m[b] \ ef, c: Nec[a]): m[Nec[b]] \ ef
SourceReturns the result of applying the applicative mapping function f
to all the elements of the
Nec c
.
def unzip(c: Nec[(a, b)]): (Nec[a], Nec[b])
SourceReturns a pair of Necs, the first containing all first components in c
and the second containing all second components in c
.
def viewLeft(c: Nec[a]): ViewLeft[a]
SourceDeconstruct a Nec from left-to-right.
Returns ViewLeft.SomeLeft(x, rs)
if the Nec has at least two elements, where x
is the leftmost
element of the Nec c
, and rs
is the rest of the Nec.
Returns ViewLeft.OneLeft
if the Nec has a single element.
def viewRight(c: Nec[a]): ViewRight[a]
SourceDeconstruct a Nec from right-to-left.
Returns ViewRight.SomeRight(rs, x)
if the Nec has at least two elements, where x
is the rightmost
element of the Nec c
, and rs
is the front of the Nec.
Returns ViewRight.OneRight
if the Nec has a single element.
def zip(c1: Nec[a], c2: Nec[b]): Nec[(a, b)]
SourceReturns a Nec where the element at index i
is (a, b)
where
a
is the element at index i
in c1
and b
is the element at index i
in c2
.
If either c1
or c2
becomes depleted, then no further elements are added to the resulting Nec.
def zipWith(f: a -> (b -> c \ ef), c1: Nec[a], c2: Nec[b]): Nec[c] \ ef
SourceReturns a Nec where the element at index i
is f(a, b)
where
a
is the element at index i
in c1
and b
is the element at index i
in c2
.
If either c1
or c2
becomes depleted, then no further elements are added to the resulting Nec.
def zipWithA(f: a -> (b -> f[c] \ ef), xs: Nec[a], ys: Nec[b]): f[Nec[c]] \ ef
SourceGeneralize zipWith
to an applicative functor f
.
def zipWithIndex(c: Nec[a]): Nec[(Int32, a)]
SourceReturns a Nec where each element e
is mapped to (i, e)
where i
is the index of e
.