morphir-sdk-core
API
Generated with
morphir-sdk-core/morphir/morphir.sdk/List

List

morphir.sdk.List
object List

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any
Self type
List.type

Members list

Type members

Types

type List[+A] = List[A]

Value members

Concrete methods

def all[A](predicate: A => Boolean)(xs: List[A]): Boolean
def any[A](predicate: A => Boolean)(xs: List[A]): Boolean
def append[A](xs: List[A])(ys: List[A]): List[A]
def apply[A](items: A*): List[A]
def concat[A](lists: List[List[A]]): List[A]
def concatMap[A, B](f: A => List[B])(lists: List[A]): List[B]
def cons[A](head: A)(tail: List[A]): List[A]
def drop[A](n: Int)(xs: List[A]): List[A]
def empty[A]: List[A]
def filter[A](f: A => Boolean)(xs: List[A]): List[A]
def filterMap[A, B](f: A => Maybe[B])(xs: List[A]): List[B]
def foldl[A, B](f: A => B => B)(initial: B)(xs: List[A]): B
def foldr[A, B](f: A => B => B)(initial: B)(xs: List[A]): B
def head[A](xs: List[A]): Maybe[A]
def indexedMap[X, R](fn: Int => X => R)(xs: List[X]): List[R]
def innerJoin[A, B](listB: List[B])(f: A => B => Bool)(listA: List[A]): List[(A, B)]
def intersperse[A](elem: A)(xs: List[A]): List[A]
def isEmpty[A](list: List[A]): Boolean
def leftJoin[A, B](listB: List[B])(f: A => B => Bool)(listA: List[A]): List[(A, Maybe[B])]
def length[A](xs: List[A]): Int
def map[A, B](mapping: A => B)(list: List[A]): List[B]
def map2[A, B, R](mapping: A => B => R)(xs: List[A])(ys: List[B]): List[R]

Combine two lists, combining them with the given function. If one list is longer, the extra elements are dropped.

Combine two lists, combining them with the given function. If one list is longer, the extra elements are dropped.

Type parameters

A

the type of the first list

B

the type of the second list

R

the type of the resulting list

Value parameters

mapping

a mapping function

xs

the first list

ys

the second list

Attributes

Returns

a list containing the combined elements of list1 and list2 using the mapping function.

def map3[X, Y, Z, R](mapping: X => Y => Z => R)(xs: List[X])(ys: List[Y])(zs: List[Z]): List[R]
def map4[A, B, C, D, R](mapping: A => B => C => D => R)(as: List[A])(bs: List[B])(cs: List[C])(ds: List[D]): List[R]
def map5[A, B, C, D, E, R](mapping: A => B => C => D => E => R)(as: List[A])(bs: List[B])(cs: List[C])(ds: List[D])(es: List[E]): List[R]
def maximum[A : Ordering](list: List[A]): Maybe[A]
def member[A, A1 >: A](candidate: A1)(xs: List[A]): Boolean
def minimum[A : Ordering](list: List[A]): Maybe[A]
def partition[A](f: A => Boolean)(xs: List[A]): (List[A], List[A])
def product[A : Numeric](list: List[A]): A
def range(start: Int)(end: Int): List[Int]
def repeat[A](n: Int)(elem: => A): List[A]
def reverse[A](xs: List[A]): List[A]
def singleton[A](item: A): List[A]
def sum[A : Numeric](list: List[A]): A
def tail[A](xs: List[A]): Maybe[List[A]]
def take[A](n: Int)(xs: List[A]): List[A]
def unzip[A, B](xs: List[(A, B)]): (List[A], List[B])
Generated with