Nel

Instance Constructors

new Nel(head: A, _tail: List[A])

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def ++(as: List[A]): List[A]

Append a list to this list.
Append a list to this list. O(n) on the size of this list

Definition Classes
List
final def ::(a: A): Nel[A]

Prepend the given value to this List O(1)
Prepend the given value to this List O(1)

Definition Classes
List
final def :::(as: Nel[A]): Nel[A]
final def :::(as: List[A]): Nel[A]

Append a list to this list.
Append a list to this list. O(n) on the size of this list

Definition Classes
Nel → List
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def coflatMap[B](f: (Nel[A]) ⇒ B): Nel[B]
def coflatMap[B](f: (List[A]) ⇒ B): List[B]

Apply a function extracting a B from every sublist, accumuating all the Bs into a List O(n)
Apply a function extracting a B from every sublist, accumuating all the Bs into a List O(n)

Definition Classes
List
final def contains(a: A)(implicit ev: Eq[A]): Boolean

Returns true if the given value is present in the List.
Returns true if the given value is present in the List. O(n)

Definition Classes
List
final def drop(num: Int): List[A]

Returns a List containing the first n elements of this List, if n * < the length of this list, the result will be a copy of this list.
Returns a List containing the first n elements of this List, if n * < the length of this list, the result will be a copy of this list. O(num)

Definition Classes
List
Annotations
@tailrec()
final def dropWhile(pred: (A) ⇒ Boolean): List[A]

Returns the list with the longest prefix of As matching the given predicate removed.
Returns the list with the longest prefix of As matching the given predicate removed.

Definition Classes
List
Annotations
@tailrec()
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def exists(pred: (A) ⇒ Boolean): Boolean

Returns true of any element in the List matches the given predicate.
Returns true of any element in the List matches the given predicate. O(n)

Definition Classes
List
final def filter(pred: (A) ⇒ Boolean): List[A]

Construct a new List containing only elements of this List which pass the given predicate O(n)
Construct a new List containing only elements of this List which pass the given predicate O(n)

Definition Classes
List
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def find(pred: (A) ⇒ Boolean): Option[A]

Return the first element in the List matching the given predicate, if one is found at all.
Return the first element in the List matching the given predicate, if one is found at all. O(n)

Definition Classes
List
Annotations
@tailrec()
final def flatMap[B](f: (A) ⇒ List[B]): List[B]

Apply a function returning a List to each element of this List, return a List which is the concatenation of all the resulting Lists.
Apply a function returning a List to each element of this List, return a List which is the concatenation of all the resulting Lists. O(n)

Definition Classes
List
final def foldLeft[B](b: B)(f: (B, A) ⇒ B): B

A left-associated fold of the List, which accumuates a B value by passing each element of the List to the given accumulating function.
A left-associated fold of the List, which accumuates a B value by passing each element of the List to the given accumulating function. O(n)

Definition Classes
List
Annotations
@tailrec()
final def foldRight[B](b: Eval[B])(f: (A, Eval[B]) ⇒ Eval[B]): Eval[B]

A right-associative fold on the list which evaluates the tail of the list lazily, allowing this computation to terminate before evailuating all of the elements on the list O(n)
A right-associative fold on the list which evaluates the tail of the list lazily, allowing this computation to terminate before evailuating all of the elements on the list O(n)

Definition Classes
List
final def forall(p: (A) ⇒ Boolean): Boolean

Returns true of all elements in the List match the given predicate.
Returns true of all elements in the List match the given predicate. O(n)

Definition Classes
List
def foreach(f: (A) ⇒ Unit): Unit

Execute the side-effecting function on each memeber of the list, in order
Execute the side-effecting function on each memeber of the list, in order

Definition Classes
List
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
val head: A
final def headOption: Option[A]

Return the head of the list, if one exists
Return the head of the list, if one exists

Definition Classes
List
final def isEmpty: Boolean

Definition Classes
Nel → List
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def map[B](f: (A) ⇒ B): Nel[B]

Apply a function to each element of this list, producing a new list with the results.
Apply a function to each element of this list, producing a new list with the results. O(n)

Definition Classes
Nel → List
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def reduceLeft(f: (A, A) ⇒ A): A
final def reverse: Nel[A]

Return a List which contains all of the same elements as this List, but in the opposite order O(n)
Return a List which contains all of the same elements as this List, but in the opposite order O(n)

Definition Classes
Nel → List
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tail: List[A]
final def tailOption: Option[List[A]]

Return the tail of the list, if one exists
Return the tail of the list, if one exists

Definition Classes
List
final def tails: Streaming[List[A]]

Returns a stream of Lists.
Returns a stream of Lists. the first list is this, and the rest of the stream are the lists generated by subsequently calilng tailOption as long as the list is non-empty.

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

Returns a List containing the first n elements of this List, if n < the length of this list, the result will be a copy of this list.
Returns a List containing the first n elements of this List, if n < the length of this list, the result will be a copy of this list. O(num)

Definition Classes
Nel → List
final def takeWhile(pred: (A) ⇒ Boolean): List[A]

Returns the longest prefix of elements which match the given predicate.
Returns the longest prefix of elements which match the given predicate.

Definition Classes
List
final def toNel: Option[Nel[A]]

Definition Classes
List
def toScalaList: scala.List[A]

Definition Classes
List
def toString(): String

Definition Classes
List → AnyRef → Any
final def unzip[B, C](implicit unz: =:=[(B, C), A]): (List[B], List[C])

If there is proof that this is a list of (B,C) return a tuple of the lists with the elements separated
If there is proof that this is a list of (B,C) return a tuple of the lists with the elements separated

Definition Classes
List
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def zip[B](bs: List[B]): List[(A, B)]

Returns a list of (A,B) pairs.
Returns a list of (A,B) pairs. If one list is longer than the other, the reminaing elements are ignored

Definition Classes
List
final def zipWithIndex: List[(A, Int)]

Returns a list of (A,Int) where each A is paired with its zero-based index in the list
Returns a list of (A,Int) where each A is paired with its zero-based index in the list

Definition Classes
List

Related Docs: object Nel | package dogs

final case class Nel[A](head: A, _tail: List[A]) extends List[A] with Product with Serializable

Instance Constructors

new Nel(head: A, _tail: List[A])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++(as: List[A]): List[A]

final def ::(a: A): Nel[A]

final def :::(as: Nel[A]): Nel[A]

final def :::(as: List[A]): Nel[A]

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def coflatMap[B](f: (Nel[A]) ⇒ B): Nel[B]

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

final def contains(a: A)(implicit ev: Eq[A]): Boolean

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

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

final def eq(arg0: AnyRef): Boolean

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

final def filter(pred: (A) ⇒ Boolean): List[A]

def finalize(): Unit

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

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

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

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

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

def foreach(f: (A) ⇒ Unit): Unit

final def getClass(): Class[_]

val head: A

final def headOption: Option[A]

final def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def reduceLeft(f: (A, A) ⇒ A): A

final def reverse: Nel[A]

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

def tail: List[A]

final def tailOption: Option[List[A]]

final def tails: Streaming[List[A]]

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

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

final def toNel: Option[Nel[A]]

def toScalaList: scala.List[A]

def toString(): String

final def unzip[B, C](implicit unz: =:=[(B, C), A]): (List[B], List[C])

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def zip[B](bs: List[B]): List[(A, B)]

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

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from List[A]

Inherited from AnyRef

Inherited from Any

Ungrouped