Attributes
Members list
Type members
Inherited and Abstract types
The names of the product elements
The names of the product elements
Attributes
- Inherited from:
- Mirror
The name of the type
The name of the type
Attributes
- Inherited from:
- Mirror
Value members
Concrete methods
Creates a list from a variable number of arguments.
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.
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.
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.
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.
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.
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 listsa
andb
. - Example
-
List.map2(List(BigInt(1), BigInt(2)), List(BigInt(3), BigInt(4)))(_ + _) === Cons(BigInt(4), Cons(BigInt(6), Nil)) List.map2(List.empty[BigInt], List(BigInt(1), BigInt(2)))(_ + _) === Nil
Creates a list containing a range of BigInt
values, inclusive of both endpoints.
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 fromfrom
toto
, 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.
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 fromfrom
toto-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
Extensions
Extensions
Converts to a scala.Seq
Converts to a scala.Seq
Attributes
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 returnstrue
if the element should be included in the resulting list, orfalse
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(1, Cons(2, Cons(3, Nil))) val filtered = list.filter(_ % 2 == 1) filtered === Cons(1, Cons(3, Nil))
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 returnstrue
if the element matches the condition.
Attributes
- Returns
-
An
Option
containing the first element that satisfies the predicate, orNone
if no such element exists. - Example
-
List.empty[BigInt].find(_ > 1) === None val list: List[BigInt] = Cons(1, Cons(2, Cons(3, Nil))) list.find(_ > 1) === Some(2) list.find(_ > 3) === None
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(1, Cons(2, Cons(3, Nil))) val sum = list.foldLeft(BigInt(0))(_ + _) sum === BigInt(6)
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
-
var sum = BigInt(0) val list: List[BigInt] = Cons(1, Cons(2, Cons(3, Nil))) list.foreach(elem => sum += elem) sum === BigInt(6)
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, orNone
if the index is out of bounds. - Example
-
List.empty[BigInt].get(0) === None val list: List[BigInt] = Cons(1, Cons(2, Cons(3, Nil))) list.get(1) === Some(2) list.get(3) === None list.get(-1) === None
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))))
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))))
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)))
Returns the first element of the list.
Returns the first element of the list.
Attributes
- Returns
-
The first element of the list.
- Throws
-
NoSuchElementException
If the list is empty.
- Example
-
val list: List[BigInt] = Cons(1, Cons(2, Cons(3, Nil))) list.head === BigInt(1) // List.empty[BigInt].head would throw NoSuchElementException
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, orNone
if the list is empty. - Example
-
List.empty[BigInt].headOption === None val list: List[BigInt] = Cons(1, Cons(2, Cons(3, Nil))) list.headOption === Some(1)
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, orNone
if the element is not found. - Example
-
List.empty[BigInt].indexOfOption(BigInt(2)) === None val list: List[BigInt] = Cons(1, Cons(2, Cons(3, Nil))) list.indexOfOption(BigInt(2)) === Some(BigInt(1)) list.indexOfOption(BigInt(4)) === None
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(1, Nil).isEmpty === false
Returns the last element of the list.
Returns the last element of the list.
Attributes
- Returns
-
An
Option
containing the last element of the list, orNone
if the list is empty. - Example
-
List.empty[BigInt].lastOption === None val list: List[BigInt] = Cons(1, Cons(2, Cons(3, Nil))) list.lastOption === Some(3)
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(1, Cons(2, Cons(3, Nil))) list.length === BigInt(3)
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 typeB
.
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(1, Cons(2, Cons(3, Nil))) val result = list.map(_ * 2) result === Cons(2, Cons(4, .Cons(6, Nil)))
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(1, Nil).nonEmpty === true
Adds an element at the beginning of this list
Adds an element at the beginning of this list
Attributes
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(1, Cons(2, Cons(3, Nil))) list.reverse === Cons(3, Cons(2, Cons(1, Nil)))
Alias for length
.
Alias for length
.
Attributes
- Returns
-
The number of elements in the list as a
BigInt
.
Returns a list consisting of all elements except the first.
Returns a list consisting of all elements except the first.
Attributes
- Returns
-
A list containing all elements except the first.
- Throws
-
NoSuchElementException
If the list is empty.
- Example
-
val list: List[BigInt] = Cons(1, Cons(2, Cons(3, Nil))) list.tail === Cons(2, Cons(3, Nil)) // List.empty[BigInt].tail would throw NoSuchElementException