Question

I’m trying to make a function that does the following: it gets a list for example [1,4,2,3] and it gives a list back [3,2,1].

Because 1 - 4 = 3 (abs value), 4 - 2 = 2 and 2 - 3 = 1.

I thought this piece of code would do that except for the abs value.

function :: [a] -> [a]
function [] = []
function (x:xs) = [x - head(xs)] ++ function xs

but it’s giving me errors and I don’t find any solution.

Kind regards,

EDIT:

Thank you guys, learned so much today. Indeed i’m a beginner, i’m having a course on university that gives me prolog,haskell, scala, python,aspectj and metaprogramming. So we have per program lang 2 lessons off 2 hours and afterwards some time to make some exercices.

Next monday i have exam and zipwith, etc… we must write our own function. But thanks for the good explained tutorial, learned so much. This is the working solution:

function :: Num a => [a] -> [a]
function (x:y:xs) = [abs(x - y)] ++ function (y:xs)
function _ = []

Answer 1

If you are still interested in recursive solution.

No instance for (Num a)
  arising from a use of `-'
In the expression: x - head (xs)
In the first argument of `(++)', namely `[x - head (xs)]'
In the expression: [x - head (xs)] ++ function xs

So (-) :: Num a => a -> a -> a operator requires, that it’s arguments should be Num. So we can fix it with function :: Num a => [a] -> [a].

Now we have another problem:

> function [1,4,2,3]
[-3,2,-1,*** Exception: Prelude.head: empty list

So we should handle some cases:

function :: Num a => [a] -> [a]
function [] = []
function [_] = []
function (x:xs) = x - head xs : function xs

But it’s still not what we actually expected:

> function [1,4,2,3]
[-3,2,-1]

So we should add abs function:

function :: Num a => [a] -> [a]
function [] = []
function [_] = []
function (x:xs) = abs ( x - head xs ) : function xs

Done

> function [1,4,2,3]
[3,2,1]

---

Beside that you can do that really easy and with more readable code.

How can you find a difference between two lists? zipWith looks really helpful here. For example:

> zipWith (-) [1,2,3,4] [1,1,1]
[0,1,2]

So idea is to zipWith (-) original list and it’s tail.

> let x = [1,2,3,4]
> zipWith (-) x (tail x)
[-1,-1,-1]

And your function could like like that:

function :: Num a => [a] -> [a]
function x = map abs $ zipWith (-) x (tail x)

Done

> function [1,4,2,3]
[3,2,1]