List

scalus.prelude.List

See theList companion enum

object List

Attributes

Companion: enum
Graph
Supertypes: trait Sum

trait Mirror

class Object

trait Matchable

class Any
Self type: List.type

Members list

Type members

Inherited and Abstract types

The names of the product elements

Attributes

Inherited from:: Mirror

The name of the type

Attributes

Inherited from:: Mirror

Value members

Concrete methods

Creates a list from a variable number of arguments.

This method allows creating a list by simply providing the elements. Works only offchain.

Type parameters

A: The type of elements in the list.

Value parameters

args: The elements to include in the list.

Attributes

Returns

A list containing all provided arguments.

Example

 List("a", "b", "c") === Cons("a", Cons("b", Cons("c", Nil)))
 List() === Nil

Returns an empty list.

This is an inline function that creates a new empty list of the specified type.

Type parameters

A: The type of elements this empty list would contain.

Attributes

Returns: An empty list of type List[A].

Creates a list by repeating a value a specified number of times.

If times is less than or equal to 0, an empty list is returned.

Type parameters

A: The type of the value to repeat.

Value parameters

times: The number of times to repeat the value.
value: The value to repeat in the list.

Attributes

Returns

A list containing the specified value repeated times times.

Example

 List.fill("a", 3) === Cons("a", Cons("a", Cons("a", Nil)))
 List.fill(true, 0) === Nil
 List.fill("x", -1) === Nil

Creates a list from any Scala iterable collection.

Works only offchain.

Type parameters

A: The type of elements in the list.

Value parameters

i: The iterable collection to convert to a list.

Attributes

Returns

A list containing all elements from the provided iterable.

Example

 List.from(Vector(BigInt(1), BigInt(2), BigInt(3))) === Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 List.from(Iterator.empty) === Nil

Creates a list from a Java iterable collection.

Works only offchain.

Type parameters

A: The type of elements in the list.

Value parameters

i: The Java iterable collection to convert to a list.

Attributes

Returns

A list containing all elements from the provided Java iterable.

Example

 import java.util.Arrays
 val javaList = Arrays.asList("a", "b", "c")
 List.from(javaList) === Cons("a", Cons("b", Cons("c", Nil)))
 val emptyJavaList = new java.util.ArrayList[String]()
 List.from(emptyJavaList) === Nil

Combines two lists element-wise using the provided function.

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

Type parameters

A: The element type of the first list.
B: The element type of the second list.
C: The element type of the resulting list.

Value parameters

a: The first list.
b: The second list.
f: A function that takes one element from each list and produces a result.

Attributes

Returns

A list containing the results of applying function f to corresponding elements of lists a and b.

Example

 val list1 = Cons(BigInt(1), Cons(BigInt(2), Nil))
 val list2 = Cons(BigInt(3), Cons(BigInt(4), Nil))
 List.map2(list1, list2)(_ + _) === Cons(BigInt(4), Cons(BigInt(6), Nil))
 List.map2(List.empty[BigInt], list1)(_ + _) === Nil

Creates a list containing a range of BigInt values, inclusive of both endpoints.

This method creates a list containing all integers from from up to and including to. If from is greater than to, an empty list is returned.

Value parameters

from: The starting value of the range (inclusive).
to: The ending value of the range (inclusive).

Attributes

Returns

A list containing all BigInt values from from to to, inclusive.

Example

 List.range(1, 3) === Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 List.range(5, 3) === Nil
 List.range(0, 0) === Cons(BigInt(0), Nil)

Creates a list containing a range of BigInt values, inclusive of the start but exclusive of the end.

This method creates a list containing all integers from from up to but not including to. If from is greater than or equal to to, an empty list is returned.

Value parameters

from: The starting value of the range (inclusive).
to: The ending value of the range (exclusive).

Attributes

Returns

A list containing all BigInt values from from to to-1, inclusive.

Example

 List.rangeUntil(1, 4) === Cons(BigInt(1), Cons(BigInt(2), Cons(BigInt(3), Nil)))
 List.rangeUntil(5, 5) === Nil
 List.rangeUntil(5, 3) === Nil

Creates a list with a single element

Attributes

Givens

Provides an Eq instance for List[A] where value type is instances of Eq.

Attributes

Provides a FromData instance for List[A] where value type is instances of FromData.

Attributes

Provides an Ord instance for List[A] where value type is instances of Ord.

Attributes

Provides a ToData instance for List[A] where value type is instances of ToData.

Attributes

Extensions

extension [A](elem: A)

Alias on prepended

Attributes

extension [A](self: List[A])

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

extension [A](self: List[List[A]])

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

extension [A](self: List[A])

Alias for at

Attributes

Alias for appendedAll.

Attributes

Alias for appended.

Attributes

Alias for appendedAll.

Attributes

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)))

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))))

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))

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

Alias for appendedAll.

Attributes

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

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)

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

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

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)))

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

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

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

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

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))

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))

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)

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

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

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))))

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)

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)

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

Applies the given function to each element of the list.

Value parameters

f: The function to apply to each element.

Attributes

Example

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

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))))

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))))

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)))

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

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

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)

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

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

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

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

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

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

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)

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)))

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

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)))

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)))

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)))

Alias for length.

Attributes

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

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

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

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

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

extension [A](self: List[A])

Alias on prependedAll

Attributes

In this article

Generated with