NonEmptyList

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++[AA >: A](l: List[AA]): NonEmptyList[AA]

def ::[AA >: A](a: AA): NonEmptyList[AA]

final def ==(arg0: Any): Boolean

def ===[AA >: A](o: NonEmptyList[AA])(implicit AA: Eq[AA]): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def coflatMap[B](f: (NonEmptyList[A]) ⇒ B): NonEmptyList[B]

def collect[B](pf: PartialFunction[A, B]): List[B]

Builds a new List by applying a partial function to all the elements from this NonEmptyList on which the function is defined

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3, 4, 5)
scala> nel.collect { case v if v < 3 => v }
res0: scala.collection.immutable.List[Int] = List(1, 2)
scala> nel.collect {
     |  case v if v % 2 == 0 => "even"
     |  case _ => "odd"
     | }
res1: scala.collection.immutable.List[String] = List(odd, even, odd, even, odd)

def concat[AA >: A](other: List[AA]): NonEmptyList[AA]

def concatNel[AA >: A](other: NonEmptyList[AA]): NonEmptyList[AA]

Append another NonEmptyList

def distinct[AA >: A](implicit O: Order[AA]): NonEmptyList[AA]

Remove duplicates.

final def eq(arg0: AnyRef): Boolean

def exists(p: (A) ⇒ Boolean): Boolean

Check whether at least one element satisfies the predicate

def filter(p: (A) ⇒ Boolean): List[A]

Remove elements not matching the predicate

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3, 4, 5)
scala> nel.filter(_ < 3)
res0: scala.collection.immutable.List[Int] = List(1, 2)

def filterNot(p: (A) ⇒ Boolean): List[A]

Remove elements matching the predicate

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3, 4, 5)
scala> nel.filterNot(_ < 3)
res0: scala.collection.immutable.List[Int] = List(3, 4, 5)

def finalize(): Unit

def find(p: (A) ⇒ Boolean): Option[A]

Find the first element matching the predicate, if one exists

def flatMap[B](f: (A) ⇒ NonEmptyList[B]): NonEmptyList[B]

def foldLeft[B](b: B)(f: (B, A) ⇒ B): B

Left-associative fold on the structure using f.

def foldRight[B](lb: Eval[B])(f: (A, Eval[B]) ⇒ Eval[B]): Eval[B]

Right-associative fold on the structure using f.

def forall(p: (A) ⇒ Boolean): Boolean

Check whether all elements satisfy the predicate

final def getClass(): Class[_]

def groupBy[B](f: (A) ⇒ B)(implicit B: Order[B]): SortedMap[B, NonEmptyList[A]]

Groups elements inside this NonEmptyList according to the Order of the keys produced by the given mapping function.

scala> import scala.collection.immutable.SortedMap
scala> import cats.data.NonEmptyList
scala> import cats.instances.boolean._
scala> val nel = NonEmptyList.of(12, -2, 3, -5)
scala> nel.groupBy(_ >= 0)
res0: SortedMap[Boolean, cats.data.NonEmptyList[Int]] = Map(false -> NonEmptyList(-2, -5), true -> NonEmptyList(12, 3))

val head: A

def init: List[A]

Selects all elements except the last

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3, 4, 5)
scala> nel.init
res0: scala.collection.immutable.List[Int] = List(1, 2, 3, 4)

final def isInstanceOf[T0]: Boolean

def last: A

Selects the last element

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3, 4, 5)
scala> nel.last
res0: Int = 5

def length: Int

def map[B](f: (A) ⇒ B): NonEmptyList[B]

Applies f to all the elements of the structure

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def prepend[AA >: A](a: AA): NonEmptyList[AA]

def reduce[AA >: A](implicit S: Semigroup[AA]): AA

Reduce using the Semigroup of AA.

def reduceLeft[AA >: A](f: (AA, AA) ⇒ AA): AA

Left-associative reduce using f.

def reverse: NonEmptyList[A]

Reverse this NonEmptyList.

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3)
scala> nel.reverse
res0: cats.data.NonEmptyList[Int] = NonEmptyList(3, 2, 1)

def show[AA >: A](implicit AA: Show[AA]): String

def size: Int

The size of this NonEmptyList

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3, 4, 5)
scala> nel.size
res0: Int = 5

def sortBy[B](f: (A) ⇒ B)(implicit B: Order[B]): NonEmptyList[A]

Sorts this NonEmptyList according to an Order on transformed B from A

scala> import cats.data.NonEmptyList
scala> import cats.instances.int._
scala> val nel = NonEmptyList.of(('a', 4), ('z', 1), ('e', 22))
scala> nel.sortBy(_._2)
res0: cats.data.NonEmptyList[(Char, Int)] = NonEmptyList((z,1), (a,4), (e,22))

def sorted[AA >: A](implicit AA: Order[AA]): NonEmptyList[AA]

Sorts this NonEmptyList according to an Order

scala> import cats.data.NonEmptyList
scala> import cats.instances.int._
scala> val nel = NonEmptyList.of(12, 4, 3, 9)
scala> nel.sorted
res0: cats.data.NonEmptyList[Int] = NonEmptyList(3, 4, 9, 12)

final def synchronized[T0](arg0: ⇒ T0): T0

val tail: List[A]

def toList: List[A]

Return the head and tail into a single list

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1, 2, 3, 4, 5)
scala> nel.toList
res0: scala.collection.immutable.List[Int] = List(1, 2, 3, 4, 5)

def toString(): String

def traverse[G[_], B](f: (A) ⇒ G[B])(implicit G: Applicative[G]): G[NonEmptyList[B]]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def zipWith[B, C](b: NonEmptyList[B])(f: (A, B) ⇒ C): NonEmptyList[C]

Zips this NonEmptyList with another NonEmptyList and applies a function for each pair of elements.

scala> import cats.data.NonEmptyList
scala> val as = NonEmptyList.of(1, 2, 3)
scala> val bs = NonEmptyList.of("A", "B", "C")
scala> as.zipWith(bs)(_ + _)
res0: cats.data.NonEmptyList[String] = NonEmptyList(1A, 2B, 3C)

def zipWithIndex: NonEmptyList[(A, Int)]

Zips each element of this NonEmptyList with its index.

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of("a", "b", "c")
scala> nel.zipWithIndex
res0: cats.data.NonEmptyList[(String, Int)] = NonEmptyList((a,0), (b,1), (c,2))

def concat[AA >: A](other: NonEmptyList[AA]): NonEmptyList[AA]