# std.list

A linked list type.

## Types

####
type List a =
| Nil
| Cons a (List a)

A linked list type

```
let list @ { List, ? } = import! std.list
let { assert_neq } = import! std.test
assert_neq (Cons 1 Nil) Nil
```

## Values

####
let of xs : forall a . Array a -> List a

Constructs a list from an array. Useful to emulate list literals

```
let { ? } = import! std.effect
let list @ { List, ? } = import! std.list
let { assert_eq, ? } = import! std.test
seq assert_eq (list.of [1, 2]) (Cons 1 (Cons 2 Nil))
let xs : List String = list.of []
assert_eq xs Nil
```

####
let many ?alt x : forall a f . [Alternative f] -> f a -> f (List a)

####
let some ?alt x : forall a f . [Alternative f] -> f a -> f (List a)

####
let filter predicate xs : forall a . (a -> Bool) -> List a -> List a

Applies `predicate`

to each element in the list and returns a new list containing only of the
elements where `predicate`

returns `True`

```
let { ? } = import! std.effect
let list @ { List, ? } = import! std.list
let { assert_eq, ? } = import! std.test
seq assert_eq (list.filter (\x -> x /= 2) (list.of [1, 2, 3])) (list.of [1, 3])
assert_eq (list.filter (\x -> False) (list.of [1, 2, 3])) Nil
```

####
let sort xs : forall a . [Ord a] -> List a -> List a

Sorts the list using `ord`

.

```
let list @ { List, ? } = import! std.list
let { assert_eq, ? } = import! std.test
assert_eq (list.sort (list.of [2, 1, 3])) (list.of [1, 2, 3])
```

####
let eq : forall a . [Eq a] -> Eq (List a)

`Eq a`

defines equality (==) on `a`

####
let ord ?ord : forall a . [Ord a] -> Ord (List a)

`Ord a`

defines an ordering on `a`

####
let semigroup : forall a . Semigroup (List a)

`Semigroup a`

represents an associative operation on `a`

.
This means the following laws must hold:

`forall x . append x (append y z) == append (append x y) z`

####
let monoid : forall a . Monoid (List a)

`Monoid a`

represents an semigroup an which has an identity. This means
the following additional laws must hold:

`forall x . append x empty == x`

`forall x . append empty x == x`

####
let functor : Functor List

A `Functor`

represents an action on a parameterized type which does not
change the structure with the mapped type.

The following laws should hold:

`map id == id`

`map (f << g) == map f << map g`

####
let applicative : Applicative List

A `Functor`

with application.

The following laws should hold:

- wrap id <*> v = v
- wrap (<<) <
*> u <*> v <*> w = u <*> (v <*> w) - wrap f <*> wrap x = wrap (f x)
- u <
*> wrap y = wrap (\g -> g x) <*> u

####
let alternative : Alternative List

A monoid on applicative functors.

####
let monad : Monad List

A generalised interface for imperatively sequencing actions

####
let foldable : Foldable List

Operations over a data structure that can be folded which means that a functions gets called on
each element to reduce the structure to a single value (`Array`

, `List`

and `Map`

are all `Foldable`

)

####
let traversable : Traversable List

####
let show ?d : forall a . [Show a] -> Show (List a)

`Show a`

represents a conversion function from `a`

to a readable string.