You can think of zipWith as a function that combines the values of two lists. If you want to add the numbers in two lists you can do this:

zipWith (+) [1, 2, 3] [4, 5, 6]

which is the same thing as:

[1+4, 2+5, 3+6]

which results in [5, 7, 9]

When you call zipWith ($) you're just applying the functions in one list to the values in another. E.g.:

zipWith ($) [(+1), (+2), (+3)] [1, 2, 3]

is the same thing as

[($) (+1) 1, ($) (+2) 2, ($) (+3) 3]

which is the same thing as

[1+1, 2+2, 3+3]

once you've rewritten it in sane syntax.

So the example I gave:

zipWith ($) [id, (+1), id, (+1)] [1, 2, 3, 4]

is the same thing as

[id 1, 2+1, id 3, 4+1]

On Fri, Feb 6, 2015 at 12:24 PM, Roelof Wobben <r.wobben@home.nl> wrote:

YCH schreef op 6-2-2015 om 20:54:

Thanks for explanation.

2015. 2. 7. 오전 4:42에 "Alex Hammel" <ahammel87@gmail.com> 님이 작성:

This is mostly for my own recreation, feel free to ignore it.

Your solution is fine, but it lacks modularity. What if you discover that you don't actually want to double every other number but triple it? Or if the list of numbers is suddenly a list of words and you need to capitalize every other one? You don't want to have to write a new function from scratch. Let's make a function that applies any function to every other value:

everyOther :: (a -> a) -> [a] -> [a]
everyOther _ []       = []
everyOther _ [x]      = [x]
everyOther f (x:y:xs) = x : f y : everyOther f xs

doubleEveryOther :: [Int] -> [Int]
doubleEveryOther = everyOther (*2)

But hang on, what if the requirements change again and now we have to double every third value? Writing something like this is no fun:

everyThird :: (a -> a) -> [a] -> [a]
everyThird _ []         = []
everyThird _ [x]        = [x]
everyThird _ [x,y]      = [x,y]
everyThird f (x:y:z:xs) = x : y : f z : everyThird f xs

And the implementation of everyHundredAndFifth will obviously be ridiculous. Clearly what we need is an `everyNth` function which allows the programmer to specify which list elements the function is applied to.

One trick is to create a list of functions and use zipWith ($). ($) is just function application; so a list with `id` at every position except the nth will work:

λ zipWith ($) [id, (+1), id, (+1)] [1, 2, 3, 4]
[1,3,3,5]

Here I miss you,. I have only done the first chapter of the NIC course and it not talked about using zipWith.

I only learned recursion and how that worked on list.

So can you explain how only the second item is added by 1 .

As soon as I understand that part I will study the rest and I think I have more questions.

Roelof

_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://www.haskell.org/mailman/listinfo/beginners