Send Beginners mailing list submissions to
[email protected]
To subscribe or unsubscribe via the World Wide Web, visit
http://www.haskell.org/mailman/listinfo/beginners
or, via email, send a message with subject or body 'help' to
[email protected]
You can reach the person managing the list at
[email protected]
When replying, please edit your Subject line so it is more specific
than "Re: Contents of Beginners digest..."
Today's Topics:
1. Re: length problem (Roelof Wobben)
2. Re: length problem (Alex Hammel)
3. Re: length problem (Roelof Wobben)
4. Re: length problem (Alex Hammel)
----------------------------------------------------------------------
Message: 1
Date: Fri, 06 Feb 2015 21:41:49 +0100
From: Roelof Wobben <[email protected]>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Subject: Re: [Haskell-beginners] length problem
Message-ID: <[email protected]>
Content-Type: text/plain; charset="us-ascii"
An HTML attachment was scrubbed...
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20150206/0082a0e9/attachment-0001.html>
------------------------------
Message: 2
Date: Fri, 6 Feb 2015 12:47:49 -0800
From: Alex Hammel <[email protected]>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Subject: Re: [Haskell-beginners] length problem
Message-ID:
<CA+_xFeo_u=xi59xnP7kA-rN-K3yDK3VWM80xJ8=7a9d+fvu...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
Yep, that's correct
On Fri, Feb 6, 2015 at 12:41 PM, Roelof Wobben <[email protected]> wrote:
> Alex Hammel schreef op 6-2-2015 om 21:35:
>
> 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 <[email protected]> wrote:
>
>> YCH schreef op 6-2-2015 om 20:54:
>>
>> Thanks for explanation.
>> 2015. 2. 7. ?? 4:42? "Alex Hammel" <[email protected]> ?? ??:
>>
>>> 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
>> [email protected]
>> http://www.haskell.org/mailman/listinfo/beginners
>>
>>
>
>
> _______________________________________________
> Beginners mailing
> [email protected]http://www.haskell.org/mailman/listinfo/beginners
>
>
> Oke, I think I get it.
>
> So if I want to add +1 to the thirt item I can do this : ? zipWith ($)
> [id, id, (+1), id] [1, 2, 3, 4] which gives [1.2.4.4]
>
> Am i correct ?
>
> Roelof
>
>
> Roelof
>
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20150206/1d757436/attachment-0001.html>
------------------------------
Message: 3
Date: Fri, 06 Feb 2015 21:52:21 +0100
From: Roelof Wobben <[email protected]>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Subject: Re: [Haskell-beginners] length problem
Message-ID: <[email protected]>
Content-Type: text/plain; charset=UTF-8; format=flowed
Alex Hammel schreef op 6-2-2015 om 20:41:
> 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]
>
> We can use `cycle` to make an infinite list of functions and
> `replicate` to generate the padding of the function list:
>
> everyNth :: Int -> (a -> a) -> [a] -> [a]
> everyNth n f = zipWith ($) fs
> where
> fs = cycle $ replicate (n-1) id ++ [f] -- e.g. cycle [id, f]
> when n is 2
>
oke, Can you also explain what this function does exactly.
I see a variable n and f and I see cycle en replicate and a n-1
What is I want to multiply the second item by 2.
That was the challenge I had now.
Roelof
------------------------------
Message: 4
Date: Fri, 6 Feb 2015 13:07:02 -0800
From: Alex Hammel <[email protected]>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Subject: Re: [Haskell-beginners] length problem
Message-ID:
<CA+_xFersJOMLxU5ZfyfugGidHVavW85E+6-4xMQzwWG58E=t...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
`everyNth` applies a function f to every nth item in a list. If you want to
double every other item in a list you can do
everyNth 2 (*2) aList
In order to accomplish this, it makes an infinite list of functions where
every nth function is `f` (the user-supplied function) and the rest are
`id`. (This function terminates when applied to finite lists becase zipWith
stops when the shorter of it's arguments runs out). So:
everyNth 2 (*2) [1, 2, 3, 4]
is the same as
zipWith ($) [id, (*2), id, (*2)] [1, 2, 3, 4]
On Fri, Feb 6, 2015 at 12:52 PM, Roelof Wobben <[email protected]> wrote:
> Alex Hammel schreef op 6-2-2015 om 20:41:
>
>> 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]
>>
>> We can use `cycle` to make an infinite list of functions and `replicate`
>> to generate the padding of the function list:
>>
>> everyNth :: Int -> (a -> a) -> [a] -> [a]
>> everyNth n f = zipWith ($) fs
>> where
>> fs = cycle $ replicate (n-1) id ++ [f] -- e.g. cycle [id, f] when n
>> is 2
>>
>>
> oke, Can you also explain what this function does exactly.
>
> I see a variable n and f and I see cycle en replicate and a n-1
>
> What is I want to multiply the second item by 2.
> That was the challenge I had now.
>
> Roelof
>
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20150206/5c108750/attachment.html>
------------------------------
Subject: Digest Footer
_______________________________________________
Beginners mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/beginners
------------------------------
End of Beginners Digest, Vol 80, Issue 11
*****************************************
