List notation

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:
```
(x:) :: [a] -> [a]
```
. E.g.
```
iterate (' ':) []
```
creates a list of blank strings with increasing size very efficiently.
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 /. []

See also[edit]