NonEmptyList

abstract def head: A

Returns the head of this NonEmptyList.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ++[A1 >: A](that: NonEmptyList[A1]): NonEmptyList[A1]

Concatenates this NonEmptyList with the specified NonEmptyList.

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def contains[A1 >: A](a: A1)(implicit A: Equal[A1]): Boolean

Returns whether this NonEmptyList contains the specified element.

final def corresponds[B](that: NonEmptyList[B])(f: (A, B) ⇒ Boolean): Boolean

Determines whether this NonEmptyList and the specified NonEmptyList have the same length and every pair of corresponding elements of this NonEmptyList and the specified NonEmptyList satisfy the specified predicate.

final def count(f: (A) ⇒ Boolean): Int

Returns the number of elements in this NonEmptyList that satisfy the specified predicate.

final def distinct: NonEmptyList[A]

Removes duplicate elements from this NonEmptyList.

final def drop(n: Int): List[A]

Drops the first n elements from this NonEmptyList returning a List.

final def dropRight(n: Int): List[A]

Drops the last n elements from this NonEmptyList returning a List.

final def dropWhile(f: (A) ⇒ Boolean): List[A]

Drops elements from the start of this NonEmptyList that satisfy the specified predicate returning a List.

final def eq(arg0: AnyRef): Boolean

final def equals(that: Any): Boolean

Returns whether this NonEmptyList and the specified NonEmptyList are equal to each other.

final def exists(f: (A) ⇒ Boolean): Boolean

Returns whether an element exists in this NonEmptyList satisfying the specified predicate.

def finalize(): Unit

final def find(f: (A) ⇒ Boolean): Option[A]

Returns the first element in this NonEmptyList satisfying the specified predicate or None otherwise.

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

Transforms each element of this NonEmptyList to a NonEmptyList and combines them into a single NonEmptyList.

final def flatten[B](implicit ev: <:<[A, NonEmptyList[B]]): NonEmptyList[B]

Flattens a NonEmptyList of NonEmptyList values into a single NonEmptyList.

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

Folds over the elements of this NonEmptyList from left to right using the specified initial value and combining function

final def foldRight[B](z: B)(op: (A, B) ⇒ B): B

Folds over the elements of this NonEmptyList from right to left using the specified initial value and combining function.

final def forEach[F[+_], B](f: (A) ⇒ F[B])(implicit arg0: AssociativeBoth[F], arg1: Covariant[F]): F[NonEmptyList[B]]

Transforms each element of this NonEmptyList with the specified effectual function.

final def forall(f: (A) ⇒ Boolean): Boolean

Returns whether all elements of this NonEmptyList satisfy the specified predicate.

final def getClass(): Class[_]

final def hashCode(): Int

Returns the hashCode of this NonEmptyList.

final def isInstanceOf[T0]: Boolean

final def length: Int

Returns the length of this NonEmptyList.

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

Transforms the elements of this NonEmptyList with the specified function.

final def max(implicit A: Ord[A]): A

Returns the maximum element in this NonEmptyList.

final def maxBy[B](f: (A) ⇒ B)(implicit B: Ord[B]): A

Returns the maximum element in this NonEmptyList using the specified function to map values of type A to values of type B that an ordering is defined on.

final def min(implicit A: Ord[A]): A

Returns the minimum element in this NonEmptyList.

final def minBy[B](f: (A) ⇒ B)(implicit B: Ord[B]): A

Returns the minimum element in this NonEmptyList using the specified function to map values of type A to values of type B that an ordering is defined on.

final def mkString(start: String, sep: String, end: String): String

Renders the elements of this NonEmptyList as a String using the specified separator and start and end values.

final def mkString(sep: String): String

Renders the elements of this NonEmptyList as a String using the specified separator.

final def mkString: String

Renders the elements of this NonEmptyList as a String.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def peel: (A, List[A])

Decomposes the NonEmptyList into an element and a (possibly empty) List

final def peelNonEmpty: (A, Option[NonEmptyList[A]])

Returns an element of this NonEmptyList and the remainder or None, if the remainder is empty.

final def product[A1 >: A](implicit A: Associative[Prod[A1]]): A1

Returns the product of the elements of this NonEmptyList.

final def reduce[A1 >: A](implicit A: Associative[A1]): A1

Reduces the elements of this NonEmptyList using the specified associative operator.

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

Reduces the elements of this NonEmptyList from left to right using the specified function.

final def reduceMap[B](f: (A) ⇒ B)(implicit B: Associative[B]): B

Maps each element of this NonEmptyList to a type B that has an associative operation then combines them all with the associative operation.

final def reduceMapLeft[B](map: (A) ⇒ B)(reduce: (B, A) ⇒ B): B

Reduces the elements of this NonEmptyList from left to right using the function map to transform the first value to the type B and then the function reduceAll to combine the B value with each other A value.

final def reduceMapRight[B](map: (A) ⇒ B)(reduce: (A, B) ⇒ B): B

Reduces the elements of this NonEmptyList from right to left using the function map to transform the first value to the type B and then the function reduceAll to combine the B value with each other A value.

final def reduceRight[A1 >: A](f: (A1, A1) ⇒ A1): A1

Reduces the elements of this NonEmptyList from right to left using the specified function.

final def reverse: NonEmptyList[A]

Reverses the order of elements in this NonEmptyList.

final def sum[A1 >: A](implicit A: Associative[Sum[A1]]): A1

Returns the sum of the elements of this NonEmptyList.

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

final def tailNonEmpty: Option[NonEmptyList[A]]

Returns the tail of this NonEmptyList if it exists or None otherwise.

final def tails: NonEmptyList[NonEmptyList[A]]

Returns a new NonEmptyList composed of this NonEmptyList followed by each of its tails, ending with a singleton NonEmptyList.

final def take(n: Int): List[A]

Takes the first n elements from this NonEmptyList returning a List.

final def takeRight(n: Int): List[A]

Takes the last n elements from this NonEmptyList returning a List.

final def takeWhile(f: (A) ⇒ Boolean): List[A]

Takes elements from the start of this NonEmptyList that satisfy the specified predicate returning a List.

final def toCons[A1 >: A]: ::[A1]

Converts this NonEmptyList to the :: case of a List.

final def toNonEmptyChunk: NonEmptyChunk[A]

Converts this NonEmptyList to a NonEmptyChunk.

final def toString(): String

Renders this NonEmptyList as a String.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def zip[B](that: NonEmptyList[B]): NonEmptyList[(A, B)]

Zips this NonEmptyList together with the specified NonEmptyList, returning a new NonEmptyList with a length equal to the minimum of the two and elements combined pairwise.

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

Zips this NonEmptyList together with the specified NonEmptyList, returning a new NonEmptyList with a length equal to the minimum of the two and elements combined pairwise using the specified function.

final def zipWithIndex: NonEmptyList[(A, Int)]

Annotates each element of this NonEmptyList with its index.