Nil

Instance Constructors

new Nil()

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
def &(that: List[T]): List[T]

Definition Classes
List
def ++(that: List[T]): List[T]

Definition Classes
List
Annotations
@function( term = "List.append" )
def -(e: T): List[T]

Definition Classes
List
Annotations
@function( term = "%xs x. removeAll x xs" )
def --(that: List[T]): List[T]

Definition Classes
List
def :+(t: T): List[T]

Definition Classes
List
Annotations
@function( term = "%xs x. xs @ [x]" )
def ::(t: T): List[T]

Definition Classes
List
Annotations
@function( term = "%xs x. x # xs" )
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
def apply(index: BigInt): T

Definition Classes
List
Annotations
@fullBody()
final def asInstanceOf[T0]: T0

Definition Classes
Any
def chunks(s: BigInt): List[List[T]]

Definition Classes
List
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def contains(v: T): Boolean

Definition Classes
List
Annotations
@function( term = "List.member" )
def content: Set[T]

Definition Classes
List
Annotations
@function( term = "List.list.set" )
def count(p: (T) ⇒ Boolean): BigInt

Definition Classes
List
def drop(i: BigInt): List[T]

Definition Classes
List
def dropWhile(p: (T) ⇒ Boolean): List[T]

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

Definition Classes
AnyRef
def evenSplit: (List[T], List[T])

Definition Classes
List
def exists(p: (T) ⇒ Boolean): Boolean

Definition Classes
List
Annotations
@function( term = "%xs P. List.list_ex P xs" )
def filter(p: (T) ⇒ Boolean): List[T]

Definition Classes
List
def filterNot(p: (T) ⇒ Boolean): List[T]

Definition Classes
List
def finalize(): Unit

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

Definition Classes
List
Annotations
@function( term = "%xs P. List.find P xs" )
def find(e: T): Option[BigInt]

Definition Classes
List
def flatMap[R](f: (T) ⇒ List[R]): List[R]

Definition Classes
List
Annotations
@function( term = "List.bind" )
def foldLeft[R](z: R)(f: (R, T) ⇒ R): R

Definition Classes
List
Annotations
@function( term = "%bs a f. List.foldl f a bs" )
def foldRight[R](z: R)(f: (T, R) ⇒ R): R

Definition Classes
List
Annotations
@function( term = "%as b f. List.foldr f as b" )
def forall(p: (T) ⇒ Boolean): Boolean

Definition Classes
List
Annotations
@function( term = "%xs P. List.list_all P xs" )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def groupBy[R](f: (T) ⇒ R): Map[R, List[T]]

Definition Classes
List
def head: T

Definition Classes
List
def headOption: Option[T]

Definition Classes
List
def indexWhere(p: (T) ⇒ Boolean): BigInt

Definition Classes
List
def init: List[T]

Definition Classes
List
def insertAt(pos: BigInt, e: T): List[T]

Definition Classes
List
def insertAt(pos: BigInt, l: List[T]): List[T]

Definition Classes
List
def isEmpty: Boolean

Definition Classes
List
Annotations
@function( term = "List.null" )
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def last: T

Definition Classes
List
def lastOption: Option[T]

Definition Classes
List
def length: BigInt

Definition Classes
List
def map[R](f: (T) ⇒ R): List[R]

Definition Classes
List
Annotations
@function( term = "%xs f. List.list.map f xs" )
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nonEmpty: Boolean

Definition Classes
List
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def padTo(s: BigInt, e: T): List[T]

Definition Classes
List
def partition(p: (T) ⇒ Boolean): (List[T], List[T])

Definition Classes
List
def replace(from: T, to: T): List[T]

Definition Classes
List
def replaceAt(pos: BigInt, l: List[T]): List[T]

Definition Classes
List
def reverse: List[T]

Definition Classes
List
Annotations
@function( term = "List.rev" )
def rotate(s: BigInt): List[T]

Definition Classes
List
def scanLeft[R](z: R)(f: (R, T) ⇒ R): List[R]

Definition Classes
List
def scanRight[R](z: R)(f: (T, R) ⇒ R): List[R]

Definition Classes
List
def size: BigInt

Definition Classes
List
Annotations
@function( term = "Int.int o List.length" )
def slice(from: BigInt, to: BigInt): List[T]

Definition Classes
List
def split(seps: List[T]): List[List[T]]

Definition Classes
List
def splitAt(e: T): List[List[T]]

Definition Classes
List
def splitAtIndex(index: BigInt): (List[T], List[T])

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

Definition Classes
AnyRef
def tail: List[T]

Definition Classes
List
def tailOption: Option[List[T]]

Definition Classes
List
def take(i: BigInt): List[T]

Definition Classes
List
def takeWhile(p: (T) ⇒ Boolean): List[T]

Definition Classes
List
def toSet: Set[T]

Definition Classes
List
def unique: List[T]

Definition Classes
List
def updated(i: BigInt, y: T): List[T]

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( ... )
def withFilter(p: (T) ⇒ Boolean): List[T]

Definition Classes
List
def zip[B](that: List[B]): List[(T, B)]

Definition Classes
List
Annotations
@function( term = "List.zip" )

case class Nil[T]() extends List[T] with Product with Serializable

Instance Constructors

new Nil()

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def &(that: List[T]): List[T]

def ++(that: List[T]): List[T]

def -(e: T): List[T]

def --(that: List[T]): List[T]

def :+(t: T): List[T]

def ::(t: T): List[T]

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def apply(index: BigInt): T

final def asInstanceOf[T0]: T0

def chunks(s: BigInt): List[List[T]]

def clone(): AnyRef

def contains(v: T): Boolean

def content: Set[T]

def count(p: (T) ⇒ Boolean): BigInt

def drop(i: BigInt): List[T]

def dropWhile(p: (T) ⇒ Boolean): List[T]

final def eq(arg0: AnyRef): Boolean

def evenSplit: (List[T], List[T])

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

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

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

def finalize(): Unit

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

def find(e: T): Option[BigInt]

def flatMap[R](f: (T) ⇒ List[R]): List[R]

def foldLeft[R](z: R)(f: (R, T) ⇒ R): R

def foldRight[R](z: R)(f: (T, R) ⇒ R): R

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

final def getClass(): Class[_]

def groupBy[R](f: (T) ⇒ R): Map[R, List[T]]

def head: T

def headOption: Option[T]

def indexWhere(p: (T) ⇒ Boolean): BigInt

def init: List[T]

def insertAt(pos: BigInt, e: T): List[T]

def insertAt(pos: BigInt, l: List[T]): List[T]

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def last: T

def lastOption: Option[T]

def length: BigInt

def map[R](f: (T) ⇒ R): List[R]

final def ne(arg0: AnyRef): Boolean

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def padTo(s: BigInt, e: T): List[T]

def partition(p: (T) ⇒ Boolean): (List[T], List[T])

def replace(from: T, to: T): List[T]

def replaceAt(pos: BigInt, l: List[T]): List[T]

def reverse: List[T]

def rotate(s: BigInt): List[T]

def scanLeft[R](z: R)(f: (R, T) ⇒ R): List[R]

def scanRight[R](z: R)(f: (T, R) ⇒ R): List[R]

def size: BigInt

def slice(from: BigInt, to: BigInt): List[T]

def split(seps: List[T]): List[List[T]]

def splitAt(e: T): List[List[T]]

def splitAtIndex(index: BigInt): (List[T], List[T])

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

def tail: List[T]

def tailOption: Option[List[T]]

def take(i: BigInt): List[T]

def takeWhile(p: (T) ⇒ Boolean): List[T]

def toSet: Set[T]

def unique: List[T]

def updated(i: BigInt, y: T): List[T]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter(p: (T) ⇒ Boolean): List[T]