# Declaratively constructing cons from lambdas

`cons`

should couple 2 items.

```
cons :: a -> b -> f a b
cons a b = undefined
```

Next we talk about its interface. `head`

should return the first item. `tail`

should return second item.

```
head :: f a b -> a
head _ = a
tail :: f a b -> b
tail _ = b
```

Our fictional language is a subset of haskell which only has lambdas and primitives. It does not have sum / product constructors such as `(,) or Product`

.

As such, we want to implement a container for values using functions.

We try to do something like this, to suspend and hold the values with a function.

```
\_ -> a b
```

But obviously this does not work, since this applies a to b, rather than just suspend them.

```
\f -> f a b
```

The above is the simplest way we have around this, using a function to hold a and b.

Naturally, everything then comes together:

```
cons :: a -> b -> f a b
cons a b = undefined
```

```
head :: f a b -> a
head ls = ls (\a _ -> a)
tail :: f a b -> b
tail ls = ls (\_ b -> b)
```