# Solved: append to list

Appending to a list is a very common operation when programming, particularly in functional programming languages such as Haskell. Lists In Haskell are heavily used data structures due to their flexibility and simplicity. This article delves into the ways of adding elements to a list in Haskell, providing a detailed step-by-step explanation of the logic and functions involved in this operation.

In Haskell, there are two primary methods to append to a list: the cons (:) operator and the append (++) operator. The cons operator is unary and is used to add an element at the beginning of a list, while the append operator is binary and can concatenate two lists together.

```-- Cons Operator
let list = 1 : []
-- Append Operator
let list =  ++ 
```

## The Cons Operator

The cons operator (:) is used to add an element at the start of a list. The cons operator takes an element and a list of the same type, and prepends the element to the list.

```let list = 1 : [2, 3, 4]
```
• Here, we are adding the number ‘1’ at the start of the list ‘[2, 3, 4]’.

This behavior becomes increasingly nuanced when we start nesting this operator. For instance, if we want to add multiple elements at the start of a list, we can do so by chaining the cons operator.

```let list = 1 : 2 : 3 : [4, 5, 6]
```
• This will result in the list ‘[1, 2, 3, 4, 5, 6]’.

## The Append Operator

Unlike the cons operator, the append operator (++) can glue two lists together. The result is a list that features all the elements of the first list followed by all the elements of the second list.

```let list = [1, 2, 3] ++ [4, 5, 6]
```
• This will return the list ‘[1, 2, 3, 4, 5, 6]’.

It’s worth noting the distinction between the cons and append operators: while append can only concatenate two lists, cons can prepend a single element to a list.

In summary, Haskell provides two essential operators for list manipulation: the cons and the append operators. Understanding how to use these operators is critical for executing complex operations and algorithms in Haskell.

Related posts: