I’m trying to combine 2 lists from input but I am getting an error every time.

Here is my code:

```
myAppend :: [a] -> [a] -> [a]
myAppend a b = zipWith (+) a b
```

Getting this error:

"No instance for (Num a) arising from a use of ‘+’"

I was given this solution but it doesn’t really make sense to me

```
myAppend :: [a] -> [a] -> [a]
myAppend [] xs = xs
myAppend (y:ys) xs = y:(myAppend ys xs)
```

I don’t really understand the second and third line.

Can anyone help?

Thanks

### >Solution :

Your `myAppend`

does not concatenate two lists, it aims to sum elementwise the two lists, so `myAppend [1,4,2,5] [1,3,0,2]`

will produce `[2,7,2,7]`

. It will require a `Num a`

constraint, since it can only work if the elements of the lists are `Num`

bers:

`myAppend :: `**Num a =>** [a] -> [a] -> [a]
myAppend a b = zipWith (+) a b

As for the solution here it uses recursion. Lists in Haskell are like linked lists: you have a an empty list ("*nil*") which is represented by the `[]`

data constructor, and a node ("*cons*") which is represented with `(x:xs)`

where `x`

points to the first item, and `xs`

points to the list of remaining elements. So `[1,4,2,5]`

is short for `(1:(4:(2:(5:[]))))`

.

If we want to append `[1,4]`

and `[2,5]`

we thus want to produce a list `(1:(4:(2:(5:[]))))`

out of `(1:(4:[]))`

and `(2:5:[])`

. This means we create a linked list with all the elements of the first list, but instead of pointing to the empty list `[]`

, we let it point to the second list for the remaining elements. We do this through recursion:

```
myAppend (y:ys) xs = y : myAppend ys xs
```

will match if the first list unifies with the `(y:ys)`

pattern. In that case we thus produce a list with `y`

as first elemnent, and the result of `myAppend ys xs`

as as list of remaining elements ("tail"). Eventually we will thus call `myAppend ys xs`

with the empty list `[]`

as first item. In that case, we thus return the second list instead of the empty list, to append the second list to it.

We thus make calls that look like:

```
myAppend [1, 4] [2, 5]
= myAppend (1:(4:[])) (2:(5:[]))
-> 1 : (myAppend (4:[]) (2:(5:[])))
-> 1 : (4 : (myAppend [] (2:(5:[]))))
-> 1 : (4 : (2:(5:[]))
= [1, 4, 2, 5]
```