List

Attributes

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(1, Cons(2, Cons(3, Nil)))
 val filtered = list.filter(_ % 2 == 1)
 filtered === Cons(1, Cons(3, Nil))

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(1, Cons(2, Cons(3, Nil)))
 list.find(_ > 1) === Some(2)
 list.find(_ > 3) === None

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)

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)

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(1, Cons(2, Cons(3, Nil)))
 list.get(1) === Some(2)
 list.get(3) === None
 list.get(-1) === None

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

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

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

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

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(1, Cons(2, Cons(3, Nil)))
 list.headOption === Some(1)

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(1, Cons(2, Cons(3, Nil)))
 list.indexOfOption(BigInt(2)) === Some(BigInt(1))
 list.indexOfOption(BigInt(4)) === None

Attributes

Returns

true if the list is empty, false otherwise.

Example

 List.empty[BigInt].isEmpty === true
 Cons(1, Nil).isEmpty       === false

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(1, Cons(2, Cons(3, Nil)))
 list.lastOption === Some(3)

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)

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(1, Cons(2, Cons(3, Nil)))
 val result = list.map(_ * 2)
 result === Cons(2, Cons(4, .Cons(6, Nil)))

Attributes

Returns

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

Example

 List.empty[BigInt].nonEmpty === false
 Cons(1, Nil).nonEmpty       === true

Attributes

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

Attributes

Returns

The number of elements in the list as a BigInt.

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