# List notation

Jump to navigation
Jump to search

The printable version is no longer supported and may have rendering errors. Please update your browser bookmarks and please use the default browser print function instead.

We are used to the list notation `[0,1,2,3]`

.
However it is syntactic sugar for `(0:1:2:3:[])`

.
By using the syntactic sugar,
we often miss the benefits of the direct notation.

- A trailing colon is like a terminator.

```
0 :
1 :
2 :
3 :
[]
```

- Thus it is more theoretically sound and easier to edit.

- You can easily mix elements and lists into a list by appending the corresponding operator in each line:

```
[1,2,3] ++
4 :
listA ++
5 :
listB ++
[]
```

- You can insert elements or sub-lists conditionally.

```
infixr 5 ?:, ?++
(?:) :: (Bool, a) -> [a] -> [a]
(?:) (b, x) = if b then (x:) else id
(?++) :: (Bool, [a]) -> [a] -> [a]
(?++) (b, x) = if b then (x++) else id
list =
[2,3] ++
(x==5, 5) ?:
(x==7, listA) ?++
[]
```

- You can construct a singleton list with a section of the colon operator: .
(:[]) :: a -> [a]

- You can prepend an element to a list: . E.g.
(x:) :: [a] -> [a]

creates a list of blank strings with increasing size very efficiently.iterate (' ':) []

- You can extend the scheme by more constructors, as in non-empty.

```
data NonEmpty f a = a :! f a
infixr 5 :!
example :: NonEmpty (NonEmpty []) Int
example = 0 :! 1 :! 2 : 3 : 4 : []
```

- You can use the
`example`

list in situations where you need to prove that the list contains at least two elements.

- You can adapt this style to other list-like data structures, e.g. a list of elements with alternating element types. See e.g. event-list.

```
data Alternating a b = Alternating a [(b,a)]
infixr 5 /., ./
(/.) :: a -> [(b,a)] -> Alternating a b
(/.) = Alternating
(./) :: b -> Alternating a b -> [(b,a)]
b ./ Alternating a bas = (b,a) : bas
example :: Alternating Bool Int
example = True /. 0 ./ False /. 1 ./ True /. []
```