final class NonEmptyChainOps[A] extends AnyVal with NonEmptyCollection[A, Chain, NonEmptyChain]
- Alphabetic
- By Inheritance
- NonEmptyChainOps
- NonEmptyCollection
- AnyVal
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
- new NonEmptyChainOps(value: NonEmptyChain[A])
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- Any
-
final
def
##(): Int
- Definition Classes
- Any
-
final
def
++[A2 >: A](c: NonEmptyChain[A2]): NonEmptyChain[A2]
Alias for concat
-
final
def
++:[A2 >: A](c: Chain[A2]): NonEmptyChain[A2]
Alias for
prependChain
Alias for
prependChain
scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(4, 5, 6) scala> Chain(1, 2, 3) ++: nec res0: cats.data.NonEmptyChain[Int] = Chain(1, 2, 3, 4, 5, 6)
-
final
def
+:[A2 >: A](a: A2): NonEmptyChain[A2]
Alias for prepend.
-
final
def
:+[A2 >: A](a: A2): NonEmptyChain[A2]
Alias for append.
-
final
def
:++[A2 >: A](c: Chain[A2]): NonEmptyChain[A2]
Alias for
appendChain
Alias for
appendChain
scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(1, 2, 4, 5) scala> nec :++ Chain(3, 6, 9) res0: cats.data.NonEmptyChain[Int] = Chain(1, 2, 4, 5, 3, 6, 9)
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- Any
-
final
def
append[A2 >: A](a: A2): NonEmptyChain[A2]
Returns a new Chain consisting of this followed by
a
.Returns a new Chain consisting of this followed by
a
. O(1) runtime.- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
appendChain[A2 >: A](c: Chain[A2]): NonEmptyChain[A2]
Appends the given chain in O(1) runtime.
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
final
def
collect[B](pf: PartialFunction[A, B]): Chain[B]
Returns a new
Chain
containing all elements where the result ofpf
is final defined.Returns a new
Chain
containing all elements where the result ofpf
is final defined.scala> import cats.data.NonEmptyChain scala> import cats.implicits._ scala> val nec = NonEmptyChain(4, 5, 6).map(n => if (n % 2 == 0) Some(n) else None) scala> nec.collect { case Some(n) => n } res0: cats.data.Chain[Int] = Chain(4, 6)
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
collectFirst[B](pf: PartialFunction[A, B]): Option[B]
Finds the first element of this
NonEmptyChain
for which the given partial function is defined, and applies the partial function to it. -
final
def
collectFirstSome[B](f: (A) ⇒ Option[B]): Option[B]
Like
collectFirst
fromscala.collection.Traversable
but takesA => Option[B]
instead ofPartialFunction
s. -
final
def
concat[A2 >: A](c: NonEmptyChain[A2]): NonEmptyChain[A2]
Concatenates this with
c
in O(1) runtime.Concatenates this with
c
in O(1) runtime.scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(1, 2, 4, 5) scala> nec ++ NonEmptyChain(7, 8) res0: cats.data.NonEmptyChain[Int] = Chain(1, 2, 4, 5, 7, 8)
-
final
def
contains(a: A)(implicit A: kernel.Eq[A]): Boolean
Tests if some element is contained in this chain.
Tests if some element is contained in this chain.
scala> import cats.data.NonEmptyChain scala> import cats.implicits._ scala> val nec = NonEmptyChain(4, 5, 6) scala> nec.contains(5) res0: Boolean = true
-
final
def
deleteFirst(f: (A) ⇒ Boolean): Option[(A, Chain[A])]
Yields to Some(a, Chain[A]) with
a
removed wheref
holds for the first time, otherwise yields None, ifa
was not found Traverses only untila
is found. -
final
def
distinct[AA >: A](implicit O: kernel.Order[AA]): NonEmptyChain[AA]
Remove duplicates.
Remove duplicates. Duplicates are checked using
Order[_]
instance.- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
exists(f: (A) ⇒ Boolean): Boolean
Tests whether a predicate holds for at least one element of this chain.
Tests whether a predicate holds for at least one element of this chain.
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
filter(p: (A) ⇒ Boolean): Chain[A]
Filters all elements of this chain that do not satisfy the given predicate.
Filters all elements of this chain that do not satisfy the given predicate.
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
filterNot(p: (A) ⇒ Boolean): Chain[A]
Filters all elements of this chain that satisfy the given predicate.
Filters all elements of this chain that satisfy the given predicate.
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
find(f: (A) ⇒ Boolean): Option[A]
Returns the first value that matches the given predicate.
Returns the first value that matches the given predicate.
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
flatMap[B](f: (A) ⇒ NonEmptyChain[B]): NonEmptyChain[B]
Applies the supplied function to each element and returns a new NonEmptyChain from the concatenated results
-
final
def
foldLeft[B](b: B)(f: (B, A) ⇒ B): B
Left-associative fold using f.
Left-associative fold using f.
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
foldRight[B](z: B)(f: (A, B) ⇒ B): B
Right-associative fold using f.
-
final
def
forall(p: (A) ⇒ Boolean): Boolean
Tests whether a predicate holds for all elements of this chain.
Tests whether a predicate holds for all elements of this chain.
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
def
getClass(): Class[_ <: AnyVal]
- Definition Classes
- AnyVal → Any
-
final
def
groupBy[B](f: (A) ⇒ B)(implicit B: kernel.Order[B]): NonEmptyMap[B, NonEmptyChain[A]]
Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given mapping function.Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given mapping function.scala> import cats.data.{NonEmptyChain, NonEmptyMap} scala> import cats.implicits._ scala> val nec = NonEmptyChain(12, -2, 3, -5) scala> val expectedResult = NonEmptyMap.of(false -> NonEmptyChain(-2, -5), true -> NonEmptyChain(12, 3)) scala> val result = nec.groupBy(_ >= 0) scala> result === expectedResult res0: Boolean = true
-
final
def
groupByNem[B](f: (A) ⇒ B)(implicit B: kernel.Order[B]): NonEmptyMap[B, NonEmptyChain[A]]
Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given mapping function.Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given mapping function.scala> import cats.data.{NonEmptyChain, NonEmptyMap} scala> import cats.implicits._ scala> val nec = NonEmptyChain(12, -2, 3, -5) scala> val expectedResult = NonEmptyMap.of(false -> NonEmptyChain(-2, -5), true -> NonEmptyChain(12, 3)) scala> val result = nec.groupByNem(_ >= 0) scala> result === expectedResult res0: Boolean = true
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
groupMap[K, B](key: (A) ⇒ K)(f: (A) ⇒ B)(implicit K: kernel.Order[K]): NonEmptyMap[K, NonEmptyChain[B]]
Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function.Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function. And each element in a group is transformed into a value of type B using the mapping function.scala> import cats.data.{NonEmptyChain, NonEmptyMap} scala> import cats.implicits._ scala> val nec = NonEmptyChain(12, -2, 3, -5) scala> val expectedResult = NonEmptyMap.of(false -> NonEmptyChain("-2", "-5"), true -> NonEmptyChain("12", "3")) scala> val result = nec.groupMap(_ >= 0)(_.toString) scala> result === expectedResult res0: Boolean = true
-
final
def
groupMapNem[K, B](key: (A) ⇒ K)(f: (A) ⇒ B)(implicit K: kernel.Order[K]): NonEmptyMap[K, NonEmptyChain[B]]
Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function.Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function. And each element in a group is transformed into a value of type B using the mapping function.scala> import cats.data.{NonEmptyChain, NonEmptyMap} scala> import cats.implicits._ scala> val nec = NonEmptyChain(12, -2, 3, -5) scala> val expectedResult = NonEmptyMap.of(false -> NonEmptyChain("-2", "-5"), true -> NonEmptyChain("12", "3")) scala> val result = nec.groupMapNem(_ >= 0)(_.toString) scala> result === expectedResult res0: Boolean = true
-
final
def
groupMapReduce[K, B](key: (A) ⇒ K)(f: (A) ⇒ B)(implicit K: kernel.Order[K], B: kernel.Semigroup[B]): NonEmptyMap[K, B]
Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function.Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function. Then each element in a group is transformed into a value of type B using the mapping function. And finally they are all reduced into a single value using theirSemigroup
scala> import cats.data.{NonEmptyChain, NonEmptyMap} scala> import cats.implicits._ scala> val nec = NonEmptyChain("Hello", "World", "Goodbye", "World") scala> val expectedResult = NonEmptyMap.of("goodbye" -> 1, "hello" -> 1, "world" -> 2) scala> val result = nec.groupMapReduce(_.trim.toLowerCase)(_ => 1) scala> result === expectedResult res0: Boolean = true
-
final
def
groupMapReduceNem[K, B](key: (A) ⇒ K)(f: (A) ⇒ B)(implicit K: kernel.Order[K], B: kernel.Semigroup[B]): NonEmptyMap[K, B]
Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function.Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function. Then each element in a group is transformed into a value of type B using the mapping function. And finally they are all reduced into a single value using theirSemigroup
scala> import cats.data.{NonEmptyChain, NonEmptyMap} scala> import cats.implicits._ scala> val nec = NonEmptyChain("Hello", "World", "Goodbye", "World") scala> val expectedResult = NonEmptyMap.of("goodbye" -> 1, "hello" -> 1, "world" -> 2) scala> val result = nec.groupMapReduceNem(_.trim.toLowerCase)(_ => 1) scala> result === expectedResult res0: Boolean = true
-
final
def
groupMapReduceWith[K, B](key: (A) ⇒ K)(f: (A) ⇒ B)(combine: (B, B) ⇒ B)(implicit K: kernel.Order[K]): NonEmptyMap[K, B]
Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function.Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function. Then each element in a group is transformed into a value of type B using the mapping function. And finally they are all reduced into a single value using the provided combine function.scala> import cats.data.{NonEmptyChain, NonEmptyMap} scala> import cats.implicits._ scala> val nec = NonEmptyChain("Hello", "World", "Goodbye", "World") scala> val expectedResult = NonEmptyMap.of("goodbye" -> 1, "hello" -> 1, "world" -> 2) scala> val result = nec.groupMapReduceWith(_.trim.toLowerCase)(_ => 1)(_ + _) scala> result === expectedResult res0: Boolean = true
-
final
def
groupMapReduceWithNem[K, B](key: (A) ⇒ K)(f: (A) ⇒ B)(combine: (B, B) ⇒ B)(implicit K: kernel.Order[K]): NonEmptyMap[K, B]
Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function.Groups elements inside this
NonEmptyChain
according to theOrder
of the keys produced by the given key function. Then each element in a group is transformed into a value of type B using the mapping function. And finally they are all reduced into a single value using the provided combine function.scala> import cats.data.{NonEmptyChain, NonEmptyMap} scala> import cats.implicits._ scala> val nec = NonEmptyChain("Hello", "World", "Goodbye", "World") scala> val expectedResult = NonEmptyMap.of("goodbye" -> 1, "hello" -> 1, "world" -> 2) scala> val result = nec.groupMapReduceWithNem(_.trim.toLowerCase)(_ => 1)(_ + _) scala> result === expectedResult res0: Boolean = true
-
final
def
grouped(size: Int): Iterator[NonEmptyChain[A]]
Partitions elements in fixed size
NonEmptyChain
s.Partitions elements in fixed size
NonEmptyChain
s.scala> import cats.data.NonEmptyChain scala> import cats.implicits._ scala> val nel = NonEmptyChain.of(12, -2, 3, -5) scala> val expectedResult = List(NonEmptyChain.of(12, -2), NonEmptyChain.of(3, -5)) scala> val result = nel.grouped(2) scala> result.toList === expectedResult res0: Boolean = true
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
head: A
Returns the first element of this NonEmptyChain.
Returns the first element of this NonEmptyChain. Amortized O(1).
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
init: Chain[A]
Returns all but the last element of this NonEmptyChain.
Returns all but the last element of this NonEmptyChain. Amortized O(1).
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
initLast: (Chain[A], A)
Returns the init and last of this NonEmptyChain.
Returns the init and last of this NonEmptyChain. Amortized O(1).
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
iterator: Iterator[A]
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
last: A
Returns the last element of this NonEmptyChain.
Returns the last element of this NonEmptyChain. Amortized O(1).
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
length: Long
Returns the number of elements in this chain.
-
final
def
map[B](f: (A) ⇒ B): NonEmptyChain[B]
Applies the supplied function to each element and returns a new NonEmptyChain.
Applies the supplied function to each element and returns a new NonEmptyChain.
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
prepend[A2 >: A](a: A2): NonEmptyChain[A2]
Returns a new NonEmptyChain consisting of
a
followed by this.Returns a new NonEmptyChain consisting of
a
followed by this. O(1) runtime.- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
prependChain[A2 >: A](c: Chain[A2]): NonEmptyChain[A2]
Prepends the given chain in O(1) runtime.
-
final
def
reduce[AA >: A](implicit S: kernel.Semigroup[AA]): AA
Reduce using the Semigroup of A
Reduce using the Semigroup of A
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
reduceLeft(f: (A, A) ⇒ A): A
Left-associative reduce using f.
Left-associative reduce using f.
scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(4, 5, 6) scala> nec.reduceLeft(_ + _) res0: Int = 15
-
final
def
reduceLeftTo[B](f: (A) ⇒ B)(g: (B, A) ⇒ B): B
Apply
f
to the "initial element" of this chain and lazily combine it with every other value using the given functiong
.Apply
f
to the "initial element" of this chain and lazily combine it with every other value using the given functiong
.scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(4, 5, 6) scala> nec.reduceLeftTo(_.toString)((acc, cur) => acc + cur.toString) res0: String = 456
-
final
def
reduceRight(f: (A, A) ⇒ A): A
Right-associative reduce using f.
Right-associative reduce using f.
scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(4, 5, 6) scala> nec.reduceRight(_ + _) res0: Int = 15
-
final
def
reduceRightTo[B](f: (A) ⇒ B)(g: (A, B) ⇒ B): B
Apply
f
to the "initial element" of this chain and lazily combine it with every other value using the given functiong
.Apply
f
to the "initial element" of this chain and lazily combine it with every other value using the given functiong
.scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(4, 5, 6) scala> nec.reduceRightTo(_.toString)((cur, acc) => acc + cur.toString) res0: String = 654
-
final
def
reverse: NonEmptyChain[A]
Reverses this
NonEmptyChain
Reverses this
NonEmptyChain
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
- final def reverseIterator: Iterator[A]
-
final
def
show[AA >: A](implicit AA: Show[AA]): String
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
sortBy[B](f: (A) ⇒ B)(implicit B: kernel.Order[B]): NonEmptyChain[A]
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
sorted[AA >: A](implicit AA: kernel.Order[AA]): NonEmptyChain[AA]
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
tail: Chain[A]
Returns all but the first element of this NonEmptyChain.
Returns all but the first element of this NonEmptyChain. Amortized O(1).
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
toChain: Chain[A]
Converts this chain to a
Chain
-
final
def
toNem[T, V](implicit ev: <:<[A, (T, V)], order: kernel.Order[T]): NonEmptyMap[T, V]
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
toNes[B >: A](implicit order: kernel.Order[B]): NonEmptySet[B]
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
toNonEmptyList: NonEmptyList[A]
Converts this chain to a
NonEmptyList
.Converts this chain to a
NonEmptyList
.scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(1, 2, 3, 4, 5) scala> nec.toNonEmptyList res0: cats.data.NonEmptyList[Int] = NonEmptyList(1, 2, 3, 4, 5)
-
final
def
toNonEmptyVector: NonEmptyVector[A]
Converts this chain to a
NonEmptyVector
.Converts this chain to a
NonEmptyVector
.scala> import cats.data.NonEmptyChain scala> val nec = NonEmptyChain(1, 2, 3, 4, 5) scala> nec.toNonEmptyVector res0: cats.data.NonEmptyVector[Int] = NonEmptyVector(1, 2, 3, 4, 5)
-
def
toString(): String
- Definition Classes
- Any
-
final
def
uncons: (A, Chain[A])
Returns the head and tail of this NonEmptyChain.
Returns the head and tail of this NonEmptyChain. Amortized O(1).
-
final
def
zipWith[B, C](b: NonEmptyChain[B])(f: (A, B) ⇒ C): NonEmptyChain[C]
Zips this
NonEmptyChain
with anotherNonEmptyChain
and applies a function for each pair of elements.Zips this
NonEmptyChain
with anotherNonEmptyChain
and applies a function for each pair of elements.scala> import cats.data.NonEmptyChain scala> val as = NonEmptyChain(1, 2, 3) scala> val bs = NonEmptyChain("A", "B", "C") scala> as.zipWith(bs)(_.toString + _) res0: cats.data.NonEmptyChain[String] = Chain(1A, 2B, 3C)
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection
-
final
def
zipWithIndex: NonEmptyChain[(A, Int)]
- Definition Classes
- NonEmptyChainOps → NonEmptyCollection