docs
API
Generated with
docs/scalus/scalus.prelude/List

List

scalus.prelude.List
See theList companion object
enum List[+A]

Attributes

Companion
object
Graph
Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
Known subtypes
class Cons[A]

Members list

Type members

Enum entries

final case class Cons[+A](head: A, tail: List[A]) extends List[A]
case Nil extends List[Nothing]

Value members

Concrete methods

inline def !!(idx: BigInt): A
Extension method from List

Alias for at

Alias for at

Attributes

inline def ++[B >: A](other: List[B]): List[B]
Extension method from List

Alias for appendedAll.

Alias for appendedAll.

Attributes

inline def ++:[B >: A](other: List[B]): List[B]
Extension method from List

Alias on prependedAll

Alias on prependedAll

Attributes

inline def :+[B >: A](elem: B): List[B]
Extension method from List

Alias for appended.

Alias for appended.

Attributes

inline def :++[B >: A](other: List[B]): List[B]
Extension method from List

Alias for appendedAll.

Alias for appendedAll.

Attributes

def appended[B >: A](elem: B): List[B]
Extension method from List

Appends an element to the end of the list.

Appends an element to the end of the list.

Type parameters

B

The type of the element, which must be a supertype of A.

Value parameters

elem

The element to append.

Attributes

Returns

A new list with the element appended.

Example 
 List.empty[BigInt].appended(BigInt(1)) === Cons(BigInt(1), Nil)
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Nil))
 list.appended(BigInt(3)) === Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
def appendedAll[B >: A](other: List[B]): List[B]
Extension method from List

Appends all elements of another list to this list.

Appends all elements of another list to this list.

Type parameters

B

The type of the elements in the other list, which must be a supertype of A.

Value parameters

other

The list whose elements will be appended.

Attributes

Returns

A new list with all elements of other appended to this list.

Example 
 List.empty[BigInt].appendedAll(List(BigInt(1), BigInt(2))) === Cons(BigInt(1), Cons(BigInt(2), Nil))
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Nil))
 list.appendedAll(List(BigInt(3), BigInt(4))) === Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Cons(BigInt(4), Nil))))
def asScala: Seq[A]
Extension method from List

Converts the list to a Scala sequence (scala.Seq).

Converts the list to a Scala sequence (scala.Seq).

This method is only available offchain.

Attributes

Returns

A scala.Seq[A] containing all the elements from this list in the same order.

Example 
 List.empty[BigInt].asScala === scala.Seq.empty[BigInt]
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.asScala === scala.Seq(BigInt(1), BigInt(2), BigInt(3))
def at(index: BigInt): A
Extension method from List

Retrieves the element at the specified index in the list.

Retrieves the element at the specified index in the list.

Value parameters

index

The zero-based BigInt index of the element to retrieve.

Attributes

Returns

The element at the specified index.

Throws
NoSuchElementException

if the index is out of bounds.

Example 
 List.empty[BigInt].at(BigInt(0)) // throws NoSuchElementException
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.at(BigInt(1)) === BigInt(2)
 list.at(BigInt(3)) // throws NoSuchElementException
 list.at(BigInt(-1)) // throws NoSuchElementException
inline def concat[B >: A](other: List[B]): List[B]
Extension method from List

Alias for appendedAll.

Alias for appendedAll.

Attributes

def contains[B >: A](elem: B)(using eq: () => B): Boolean
Extension method from List

Checks if the list contains the specified element.

Checks if the list contains the specified element.

Type parameters

B

The type of the element, which must be a supertype of A.

Value parameters

elem

The element to check for in the list.

Attributes

Returns

true if the list contains the element, false otherwise.

Example 
 List.empty[BigInt].contains(BigInt(2)) === false
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.contains(BigInt(2)) === true
 list.contains(BigInt(4)) === false
 list.contains(BigInt(-1)) === false
def count(p: A => Boolean): BigInt
Extension method from List

Counts the number of elements in the list that satisfy the given predicate.

Counts the number of elements in the list that satisfy the given predicate.

Value parameters

p

A function that takes an element of type A and returns true if the element matches the condition.

Attributes

Returns

The number of elements in the list that satisfy the predicate as a BigInt.

Example 
 List.empty[BigInt].count(_ > 1) === BigInt(0)
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.count(_ > 1) === BigInt(2)
def deleteFirst[B >: A](elem: B)(using eq: () => B): List[A]
Extension method from List

Deletes the first occurrence of the specified element from the list.

Deletes the first occurrence of the specified element from the list.

Type parameters

B

The type of the element being deleted, which must be a supertype of A

Value parameters

elem

The element to delete from the list

eq

An instance of Eq[B] used to compare elements for equality

Attributes

Returns

A new list with the first occurrence of the specified element removed, or the original list if the element is not found

Example 
 List.empty[BigInt].deleteFirst(BigInt(2)) === Nil
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(2), Nil)))
 list.deleteFirst(BigInt(2)) === Cons(BigInt(1), Cons(BigInt(2), Nil))
 list.deleteFirst(BigInt(3)) === list
def diff[B >: A](other: List[B])(using eq: () => B): List[A]
Extension method from List

Returns a new list containing elements from this list that do not appear in the other list.

Returns a new list containing elements from this list that do not appear in the other list.

Type parameters

B

The type of elements in the other list, which must be a supertype of A

Value parameters

eq

An instance of Eq[B] used to compare elements for equality

other

The list whose elements should be removed from this list

Attributes

Returns

A new list containing elements from this list that do not appear in the other list

Example 
 List.empty[BigInt].diff(List(BigInt(1), BigInt(2))) === Nil
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.diff(List(BigInt(2))) === Cons(BigInt(1), Cons(BigInt(3), Nil))
 list.diff(Nil) === list
 list.diff(list) === Nil
def distinct[B >: A](using eq: () => B): List[A]
Extension method from List

Returns a new list with duplicate elements removed, keeping only the first occurrence of each element.

Returns a new list with duplicate elements removed, keeping only the first occurrence of each element.

Type parameters

B

The type of elements being compared, which must be a supertype of A

Value parameters

eq

An instance of Eq[B] used to compare elements for equality

Attributes

Returns

A new list containing only distinct elements in their original order

Example 
 List.empty[BigInt].distinct === Nil
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(1), Cons(BigInt(3), Nil))))
 list.distinct === Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
def drop(skip: BigInt): List[A]
Extension method from List

Returns a list consisting of all elements except the first skip elements of this list.

Returns a list consisting of all elements except the first skip elements of this list.

Value parameters

skip

The number of elements to drop from the beginning of the list

Attributes

Returns

A new list with the first skip elements removed, or an empty list if skip is greater than or equal to the list's length

Example 
 List.empty[BigInt].drop(2) === Nil
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.drop(2) === Cons(BigInt(3), Nil)
 list.drop(0) === list
 list.drop(4) === Nil
def dropRight(skip: BigInt): List[A]
Extension method from List

Returns a list consisting of all elements except the last skip elements of this list.

Returns a list consisting of all elements except the last skip elements of this list.

Value parameters

skip

The number of elements to drop from the end of the list

Attributes

Returns

A new list with the last skip elements removed, or an empty list if skip is greater than or equal to the list's length

Example 
 List.empty[BigInt].dropRight(2) === Nil
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.dropRight(2) === Cons(BigInt(1), Nil)
 list.dropRight(0) === list
 list.dropRight(4) === Nil
def dropWhile(predicate: A => Boolean): List[A]
Extension method from List

Drops elements from the beginning of the list as long as they satisfy the predicate.

Drops elements from the beginning of the list as long as they satisfy the predicate.

Value parameters

predicate

A function that takes an element and returns true if it should be dropped from the result

Attributes

Returns

A new list containing all elements from the first element that does not satisfy the predicate until the end of the list

Example 
 List.empty[BigInt].dropWhile(_ < 3) === Nil
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.dropWhile(_ < 3) === Cons(BigInt(3), Nil)
 list.dropWhile(_ < 1) === list
 list.dropWhile(_ < 4) === Nil
def exists(predicate: A => Boolean): Boolean
Extension method from List

Checks if the list contains an element that satisfies the given predicate.

Checks if the list contains an element that satisfies the given predicate.

Value parameters

predicate

A function that takes an element of type A and returns true if the element matches the condition.

Attributes

Returns

true if there is at least one element in the list that satisfies the predicate, false otherwise.

Example 
 List.empty[BigInt].exists(_ > 1) === false
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.exists(_ > 1) === true
 list.exists(_ > 3) === false
def filter(predicate: A => Boolean): List[A]
Extension method from List

Filters the elements of the list based on a predicate.

Filters the elements of the list based on a predicate.

Value parameters

predicate

A function that takes an element of type A and returns true if the element should be included in the resulting list, or false otherwise.

Attributes

Returns

A new list containing only the elements that satisfy the predicate.

Example 
 List.empty[BigInt].filter(_ % 2 == 1) === Nil
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 val filtered = list.filter(_ % 2 == 1)
 filtered === Cons(BigInt(1), Cons(BigInt(3), Nil))
def filterMap[B](predicate: A => Option[B]): List[B]
Extension method from List

Filters the elements of the list based on a predicate that returns an Option[B].

Filters the elements of the list based on a predicate that returns an Option[B].

If the predicate returns None, the element is excluded from the resulting list. If it returns Some(value), the value is included in the resulting list.

Type parameters

B

The type of the values to be included in the resulting list.

Value parameters

predicate

A function that takes an element of type A and returns an Option[B].

Attributes

Returns

A new list containing only the elements for which the predicate returned Some(value).

Example 
 List.empty[BigInt].filterMap(x => if x % 2 == 1 then Some(x) else None) === Nil
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 val filtered = list.filterMap(x => if x % 2 == 1 then Some(x) else None)
 filtered === Cons(BigInt(1), Cons(BigInt(3), Nil))
def filterNot(predicate: A => Boolean): List[A]
Extension method from List

Filters the elements of the list based on a predicate that returns false for elements to be excluded.

Filters the elements of the list based on a predicate that returns false for elements to be excluded.

Value parameters

predicate

A function that takes an element of type A and returns true if the element should be excluded from the resulting list, or false otherwise.

Attributes

Returns

A new list containing only the elements that do not satisfy the predicate.

Example 
 List.empty[BigInt].filterNot(_ % 2 == 1) === Nil
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 val filtered = list.filterNot(_ % 2 == 1)
 filtered === Cons(BigInt(2), Nil)
def find(predicate: A => Boolean): Option[A]
Extension method from List

Finds the first element in the list that satisfies the given predicate.

Finds the first element in the list that satisfies the given predicate.

Value parameters

predicate

A function that takes an element of type A and returns true if the element matches the condition.

Attributes

Returns

An Option containing the first element that satisfies the predicate, or None if no such element exists.

Example 
 List.empty[BigInt].find(_ > 1) === None
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.find(_ > 1) === Some(BigInt(2))
 list.find(_ > 3) === None
def findMap[B](mapper: A => Option[B]): Option[B]
Extension method from List

Finds the first element in the list that, when passed to the provided mapper function returns non-None or None otherwise.

Finds the first element in the list that, when passed to the provided mapper function returns non-None or None otherwise.

Value parameters

mapper

A function that takes an element of type A and returns an Option[B].

Attributes

Returns

An Option[B] containing the first non-None result from applying the mapper to the elements of the list, or None if no such element exists.

Example 
 List.empty[String].findMap(str => if str.length >= 3 then Some(BigInt(str.length)) else None) === None
 val list: List[String] = Cons("a", Cons("bb", Cons("ccc", Nil)))
 list.findMap(str => if str.length >= 2 then Some(BigInt(str.length)) else None) === Some(BigInt(2))
 list.findMap(str => if str.length >= 4 then Some(BigInt(str.length)) else None) === None
def flatMap[B](mapper: A => List[B]): List[B]
Extension method from List

Applies a function to each element of the list, producing a new list with the results.

Applies a function to each element of the list, producing a new list with the results.

This method is similar to map, but it allows the function to return a list for each element, effectively flattening the result.

Value parameters

mapper

A function that takes an element of type A and returns a list of type List[B].

Attributes

Returns

A new list containing all elements produced by applying mapper to each element of the original list and flattening the results.

Example 
 List.empty[BigInt].flatMap(x => List(x, x + 1)) === Nil
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Nil))
 val result = list.flatMap(x => List(x, x + 1))
 result === Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(2), Cons(BigInt(3), Nil))))
def flatten: List[A]
Extension method from List

Flattens a list of lists into a single list.

Flattens a list of lists into a single list.

This method concatenates all inner lists into a single list.

Attributes

Returns

A new list containing all elements from the inner lists.

Example 
 val list = Cons(Cons(BigInt(1), Cons(BigInt(2), Nil)), Cons(Cons(BigInt(3), Cons(BigInt(4), Nil)), Nil))
 list.flatten === Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Cons(BigInt(4), Nil))))
 List.empty[List[BigInt]].flatten === Nil
def foldLeft[B](init: B)(combiner: (B, A) => B): B
Extension method from List

Performs a left fold on the list.

Performs a left fold on the list.

Type parameters

B

The type of the accumulated value.

Value parameters

combiner

A function that combines the accumulated value and the current element.

init

The initial value to start the fold with.

Attributes

Returns

The result of applying the combiner function to all elements of the list, starting with the initial value.

Example 
 List.empty[BigInt].foldLeft(BigInt(0))(_ + _) === BigInt(0)
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 val sum = list.foldLeft(BigInt(0))(_ + _)
 sum === BigInt(6)
def foldRight[B](init: B)(combiner: (A, B) => B): B
Extension method from List

Performs a right fold on the list.

Performs a right fold on the list.

Value parameters

B

The type of the accumulated value.

combiner

A function that combines the current element and the accumulated value.

init

The initial value to start the fold with.

Attributes

Returns

The result of applying the combiner function to all elements of the list, starting with the initial value.

Example 
 List.empty[BigInt].foldRight(BigInt(0))(_ + _) === BigInt(0)
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 val sum = list.foldRight(BigInt(0))(_ + _)
 sum === BigInt(6)
def forall(predicate: A => Boolean): Boolean
Extension method from List

Checks if all elements in the list satisfy the given predicate.

Checks if all elements in the list satisfy the given predicate.

Value parameters

predicate

A function that takes an element of type A and returns true if the element matches the condition.

Attributes

Returns

true if all elements in the list satisfy the predicate, false otherwise.

Example 
 List.empty[BigInt].forall(_ > 1) === true
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.forall(_ > 0) === true
 list.forall(_ > 2) === false
def foreach(f: A => Unit): Unit
Extension method from List

Applies the given function to each element of the list.

Applies the given function to each element of the list.

Value parameters

f

The function to apply to each element.

Attributes

Example
def get(index: BigInt): Option[A]
Extension method from List

Retrieves the element at the specified index in the list.

Retrieves the element at the specified index in the list.

Value parameters

index

The zero-based index of the element to retrieve.

Attributes

Returns

An Option containing the element at the specified index, or None if the index is out of bounds.

Example 
 List.empty[BigInt].get(0) === None
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.get(1) === Some(BigInt(2))
 list.get(3) === None
 list.get(-1) === None
def groupBy[K : Eq](keyExtractor: A => K): AssocMap[K, List[A]]
Extension method from List

Groups the elements of this list by the keys returned by the specified function.

Groups the elements of this list by the keys returned by the specified function.

Type parameters

K

The type of the keys.

Value parameters

keyExtractor

A function that extracts the key from each element.

Attributes

Returns

An AssocMap mapping each key to a list of elements that have that key.

Example 
 List.empty[BigInt].groupBy(_ % 2) === AssocMap.empty
 val list: List[BigInt] = Cons(1, Cons(2, Cons(3, Cons(4, Nil))))
 list.groupBy(_ % 2) === AssocMap.from((BigInt(1), Cons(1, Cons(3, Nil))), (BigInt(0), Cons(2, Cons(4, Nil))))
def groupMap[K : Eq, B](keyExtractor: A => K)(valueExtractor: A => B): AssocMap[K, List[B]]
Extension method from List

Groups the elements of this list by the keys returned by the key extractor function and transforms each element using the value extractor function.

Groups the elements of this list by the keys returned by the key extractor function and transforms each element using the value extractor function.

Type parameters

B

The type of the transformed elements.

K

The type of the keys.

Value parameters

keyExtractor

A function that extracts the key from each element.

valueExtractor

A function that transforms each element before collecting into groups.

Attributes

Returns

An AssocMap mapping each key to a list of transformed elements that have that key.

Example 
 List.empty[BigInt].groupMap(_ % 2)(_ * 2) === AssocMap.empty
 val list: List[BigInt] = Cons(1, Cons(2, Cons(3, Cons(4, Nil))))
 list.groupMap(_ % 2)(_ * 2) === AssocMap.from((BigInt(1), Cons(2, Cons(6, Nil))), (BigInt(0), Cons(4, Cons(8, Nil))))
def groupMapReduce[K : Eq, B](keyExtractor: A => K)(valueExtractor: A => B)(reducer: (B, B) => B): AssocMap[K, B]
Extension method from List

Groups elements by the keys returned by the key extractor function, transforms each element using the value extractor function, and combines values with the same key using the reducer function.

Groups elements by the keys returned by the key extractor function, transforms each element using the value extractor function, and combines values with the same key using the reducer function.

Type parameters

B

The type of the transformed elements.

K

The type of the keys.

Value parameters

keyExtractor

A function that extracts the key from each element.

reducer

A function that combines two values with the same key.

valueExtractor

A function that transforms each element before reduction.

Attributes

Returns

An AssocMap mapping each key to the reduced value of all elements with that key.

Example 
 List.empty[BigInt].groupMapReduce(_ % 2)(identity)(_ + _) === AssocMap.empty
 val list: List[BigInt] = Cons(1, Cons(2, Cons(3, Cons(4, Nil))))
 list.groupMapReduce(_ % 2)(identity)(_ + _) === AssocMap.from((BigInt(1), BigInt(4)), (BigInt(0), BigInt(6)))
def head: A
Extension method from List

Returns the first element of the list or throws an exception if the list is empty.

Returns the first element of the list or throws an exception if the list is empty.

Attributes

Returns

The first element of the list.

Throws
NoSuchElementException

If the list is empty.

Example 
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.head === BigInt(1)
 List.empty[BigInt].head // throw NoSuchElementException
def headOption: Option[A]
Extension method from List

Returns the first element of the list as an Option.

Returns the first element of the list as an Option.

Attributes

Returns

An Option containing the first element of the list, or None if the list is empty.

Example 
 List.empty[BigInt].headOption === None
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.headOption === Some(1)
 List.empty[BigInt].headOption === None
def indexOf[B >: A](elem: B)(using eq: () => B): BigInt
Extension method from List

Finds the index of the first occurrence of the specified element in the list.

Finds the index of the first occurrence of the specified element in the list.

Type parameters

B

The type of the element being searched for, which must be a supertype of A.

Value parameters

elem

The element to search for in the list.

Attributes

Returns

The index of the first occurrence of the element, or BigInt(-1) if the element is not found.

Example 
 List.empty[BigInt].indexOf(BigInt(2)) === BigInt(-1)
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.indexOf(BigInt(2)) === BigInt(1)
 list.indexOf(BigInt(4)) === BigInt(-1)
 list.indexOf(BigInt(-1)) === BigInt(-1)
def indexOfOption[B >: A](elem: B)(using eq: () => B): Option[BigInt]
Extension method from List

Finds the index of the first occurrence of the specified element in the list.

Finds the index of the first occurrence of the specified element in the list.

Type parameters

B

The type of the element being searched for, which must be a supertype of A.

Value parameters

elem

The element to search for in the list.

Attributes

Returns

An Option containing the index of the first occurrence of the element, or None if the element is not found.

Example 
 List.empty[BigInt].indexOfOption(BigInt(2)) === None
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.indexOfOption(BigInt(2)) === Some(BigInt(1))
 list.indexOfOption(BigInt(4)) === None
 list.indexOfOption(BigInt(-1)) === None
inline def init: List[A]
Extension method from List

Returns a new list containing all elements except the last element of this list or throws an exception if the list is empty.

Returns a new list containing all elements except the last element of this list or throws an exception if the list is empty.

Attributes

Returns

A new list containing all elements except the last.

Throws
NoSuchElementException

If the list is empty.

Example 
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.init === Cons(BigInt(1), Cons(BigInt(2), Nil))
 List.empty[BigInt].init // throw NoSuchElementException
def isDefinedAt(index: BigInt): Boolean
Extension method from List

Checks if the list contains an element at the specified index.

Checks if the list contains an element at the specified index.

Value parameters

index

The zero-based BigInt index to check.

Attributes

Returns

true if the list contains an element at the specified index, false otherwise.

Example 
 List.empty[BigInt].isDefinedAt(BigInt(0)) === false
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.isDefinedAt(BigInt(1)) === true
 list.isDefinedAt(BigInt(3)) === false
 list.isDefinedAt(BigInt(-1)) === false
def isEmpty: Boolean
Extension method from List

Checks if the list is empty.

Checks if the list is empty.

Attributes

Returns

true if the list is empty, false otherwise.

Example 
 List.empty[BigInt].isEmpty   === true
 Cons(BigInt(1), Nil).isEmpty === false
def last: A
Extension method from List

Returns the last element of the list or throws an exception if the list is empty.

Returns the last element of the list or throws an exception if the list is empty.

Attributes

Returns

The last element of the list.

Throws
NoSuchElementException

If the list is empty.

Example 
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.last === BigInt(3)
 List.empty[BigInt].last // throw NoSuchElementException
def lastOption: Option[A]
Extension method from List

Returns the last element of the list as an Option.

Returns the last element of the list as an Option.

Attributes

Returns

An Option containing the last element of the list, or None if the list is empty.

Example 
 List.empty[BigInt].lastOption === None
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.lastOption === Some(BigInt(3))
 List.empty[BigInt].lastOption === None
def length: BigInt
Extension method from List

Returns the number of elements in the list.

Returns the number of elements in the list.

Attributes

Returns

The number of elements in the list as a BigInt.

Example 
 List.empty[BigInt].length === BigInt(0)
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.length === BigInt(3)
def map[B](mapper: A => B): List[B]
Extension method from List

Applies a function to each element of the list, producing a new list with the results.

Applies a function to each element of the list, producing a new list with the results.

Value parameters

mapper

A function that takes an element of type A and returns a value of type B.

Attributes

Returns

A new list where each element is the result of applying mapper to the corresponding element of the original list.

Example 
 List.empty[BigInt].map(_ * 2) === Nil
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 val result = list.map(_ * 2)
 result === Cons(BigInt(2), Cons(BigInt(4), .Cons(BigInt(6), Nil)))
inline def nonEmpty: Boolean
Extension method from List

Checks if the list is not empty.

Checks if the list is not empty.

Attributes

Returns

true if the list contains at least one element, false otherwise.

Example 
 List.empty[BigInt].nonEmpty    === false
 Cons(BigInt(1), Nil).nonEmpty  === true
inline def prepended[B >: A](elem: B): List[B]
Extension method from List

Prepends an element to the list.

Prepends an element to the list.

Type parameters

B

The type of the element, which must be a supertype of A.

Value parameters

elem

The element to prepend.

Attributes

Returns

A new list with the element prepended.

Example 
 List.empty[BigInt].prepended(BigInt(1)) === Cons(BigInt(1), Nil)
 val list: List[BigInt] = Cons(BigInt(2), Cons(BigInt(3), Nil))
 list.prepended(BigInt(1)) === Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
inline def prependedAll[B >: A](other: List[B]): List[B]
Extension method from List

Prepends all elements of another list to this list.

Prepends all elements of another list to this list.

Type parameters

B

The type of the elements in the other list, which must be a supertype of A.

Value parameters

other

The list whose elements will be prepended.

Attributes

Returns

A new list with all elements of other prepended to this list.

Example 
 List.empty[BigInt].prependedAll(List(BigInt(1), BigInt(2))) === Cons(BigInt(1), Cons(BigInt(2), Nil))
 val list: List[BigInt] = Cons(BigInt(3), Nil)
 list.prependedAll(List(BigInt(1), BigInt(2))) === Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
def quicksort: List[A]
Extension method from List

Sorts the list using the quicksort algorithm.

Sorts the list using the quicksort algorithm.

This method sorts the elements of the list in ascending order based on the provided Ord[A] instance.

Attributes

Returns

A new list containing the elements of the original list sorted in ascending order.

Example 
 List(BigInt(3), BigInt(1), BigInt(2)).quicksort === Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 List.empty[BigInt].quicksort === Nil
def reverse: List[A]
Extension method from List

Returns a new list with elements in reverse order.

Returns a new list with elements in reverse order.

Attributes

Returns

A new list containing the same elements but in reverse order.

Example 
 List.empty[BigInt].reverse === Nil
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.reverse === Cons(BigInt(3), Cons(BigInt(2), Cons(BigInt(1), Nil)))
inline def size: BigInt
Extension method from List

Alias for length.

Alias for length.

Attributes

def tail: List[A]
Extension method from List

Returns a list consisting of all elements except the first element of this list or throws an exception if the list is empty.

Returns a list consisting of all elements except the first element of this list or throws an exception if the list is empty.

Attributes

Returns

A list containing all elements except the first.

Throws
NoSuchElementException

If the list is empty.

Example 
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.tail === Cons(BigInt(2), Cons(BigInt(3), Nil))
 List.empty[BigInt].tail // throw NoSuchElementException
def take(count: BigInt): List[A]
Extension method from List

Takes the first count elements from the list.

Takes the first count elements from the list.

Value parameters

count

The number of elements to take from the beginning of the list

Attributes

Returns

A new list containing the first count elements, or an empty list if count is less than or equal to 0

Example 
 List.empty[BigInt].take(2) === Nil
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.take(2) === Cons(BigInt(1), Cons(BigInt(2), Nil))
 list.take(0) === Nil
 list.take(4) === list
def takeRight(count: BigInt): List[A]
Extension method from List

Takes the last count elements from the list.

Takes the last count elements from the list.

Value parameters

count

The number of elements to take from the end of the list

Attributes

Returns

A new list containing the last count elements, or an empty list if count is less than or equal to 0

Example 
 List.empty[BigInt].takeRight(2) === Nil
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.takeRight(2) === Cons(BigInt(2), Cons(BigInt(3), Nil))
 list.takeRight(0) === Nil
 list.takeRight(4) === list
def takeWhile(predicate: A => Boolean): List[A]
Extension method from List

Takes elements from the beginning of the list as long as they satisfy the predicate.

Takes elements from the beginning of the list as long as they satisfy the predicate.

Value parameters

predicate

A function that takes an element and returns true if it should be included in the result

Attributes

Returns

A new list containing elements from the beginning of the list until an element is found that does not satisfy the predicate

Example 
 List.empty[BigInt].takeWhile(_ < 3) === Nil
 val list: List[BigInt] = Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 list.takeWhile(_ < 3) === Cons(BigInt(1), Cons(BigInt(2), Nil))
 list.takeWhile(_ < 1) === Nil
 list.takeWhile(_ < 4) === list
def zip[B](other: List[B]): List[(A, B)]
Extension method from List

Zips this list with another list, producing a list of pairs.

Zips this list with another list, producing a list of pairs.

The resulting list will have the length of the shorter of the two lists.

Type parameters

B

The type of elements in the other list.

Value parameters

other

The other list to zip with.

Attributes

Returns

A list of pairs, where each pair contains an element from this list and an element from the other list at the same index.

Example 
 List(BigInt(1), BigInt(2)).zip(List(BigInt(3), BigInt(4))) === Cons((BigInt(1), BigInt(3)), Cons((BigInt(2), BigInt(4)), Nil))
 List.empty[BigInt].zip(List(BigInt(1), BigInt(2))) === Nil
Generated with