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

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

type MirroredElemLabels <: Tuple

The names of the product elements

The names of the product elements

Attributes

Inherited from:
Mirror
type MirroredLabel <: String

The name of the type

The name of the type

Attributes

Inherited from:
Mirror

Value members

Concrete methods

def apply[A](args: A*): List[A]

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
inline def empty[A]: List[A]

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].

def fill[A](value: A, times: BigInt): 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
def from[A](i: IterableOnce[A]): List[A]

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
def from[A](i: Iterable[A]): List[A]

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
def map2[A, B, C](a: List[A], b: List[B])(f: (A, B) => C): List[C]

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 lists a and b.

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
def range(from: BigInt, to: BigInt): List[BigInt]

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 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)
def rangeUntil(from: BigInt, to: BigInt): List[BigInt]

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 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
def single[A](a: A): List[A]

Creates a list with a single element

Creates a list with a single element

Attributes

Givens

Givens

given listEq[A : Eq]: () => List[A]
given listOrd[A : Ord]: () => List[A]
given listToData[A : ToData]: ToData[List[A]]

Extensions

Extensions

extension [A](self: List[A])
inline def ++:[B >: A](other: List[B]): List[B]
inline def +:[B >: A](elem: B): List[B]
extension [A](self: List[A])
inline def !!(idx: BigInt): A
inline def ++[B >: A](other: List[B]): List[B]
inline def :+[B >: A](elem: B): List[B]
inline def :++[B >: A](other: List[B]): List[B]
def appended[B >: A](elem: B): List[B]
def appendedAll[B >: A](other: List[B]): List[B]
def asScala: Seq[A]

Converts to a scala.Seq

Converts to a scala.Seq

Attributes

def at(index: BigInt): A
inline def concat[B >: A](other: List[B]): List[B]
def contains[B >: A](elem: B)(using eq: () => B): Boolean
def count(p: A => Boolean): BigInt
def drop(skip: BigInt): List[A]
def dropRight(skip: BigInt): List[A]
def exists(predicate: A => Boolean): Boolean
def filter(predicate: A => Boolean): List[A]

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(1, Cons(2, Cons(3, Nil)))
 val filtered = list.filter(_ % 2 == 1)
 filtered === Cons(1, Cons(3, Nil))
def filterMap[B](predicate: A => Option[B]): List[B]
def find(predicate: A => Boolean): Option[A]

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(1, Cons(2, Cons(3, Nil)))
 list.find(_ > 1) === Some(2)
 list.find(_ > 3) === None
def flatMap[B](mapper: A => List[B]): List[B]
def foldLeft[B](init: B)(combiner: (B, A) => B): B

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)
def foldRight[B](init: B)(combiner: (A, B) => B): B
def forall(predicate: A => Boolean): Boolean
def foreach(f: A => Unit): Unit

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)
def get(index: BigInt): Option[A]

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(1, Cons(2, Cons(3, Nil)))
 list.get(1) === Some(2)
 list.get(3) === None
 list.get(-1) === None
def groupBy[K : Eq](keyExtractor: A => K): AssocMap[K, List[A]]

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

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]

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

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
def headOption: Option[A]

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(1, Cons(2, Cons(3, Nil)))
 list.headOption === Some(1)
def indexOf[B >: A](elem: B)(using eq: () => B): BigInt
def indexOfOption[B >: A](elem: B)(using eq: () => B): Option[BigInt]

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(1, Cons(2, Cons(3, Nil)))
 list.indexOfOption(BigInt(2)) === Some(BigInt(1))
 list.indexOfOption(BigInt(4)) === None
inline def init: List[A]
def isDefinedAt(index: BigInt): Boolean
def isEmpty: Boolean

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
def last: A
def lastOption: Option[A]

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, 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)
def length: BigInt

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)
def map[B](mapper: A => B): List[B]

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

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
inline def prepended[B >: A](elem: B): List[B]

Adds an element at the beginning of this list

Adds an element at the beginning of this list

Attributes

inline def prependedAll[B >: A](other: List[B]): List[B]
def reverse: List[A]

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)))
inline def size: BigInt

Alias for length.

Alias for length.

Attributes

Returns

The number of elements in the list as a BigInt.

def tail: List[A]

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
def zip[B](other: List[B]): List[(A, B)]
extension [A](self: Seq[A])
def asScalus: List[A]

Converts a scala.Seq to a List

Converts a scala.Seq to a List

Attributes

Generated with