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: A post about Currying and Partial application
(Petar Radosevic)
2. Re: A post about Currying and Partial application
(Chadda? Fouch?)
3. Re: A post about Currying and Partial application (Rustom Mody)
4. Re: A post about Currying and Partial application
(Felipe Almeida Lessa)
5. Re: A post about Currying and Partial application
(Petar Radosevic)
----------------------------------------------------------------------
Message: 1
Date: Sat, 1 Oct 2011 14:40:15 +0200
From: Petar Radosevic <[email protected]>
Subject: Re: [Haskell-beginners] A post about Currying and Partial
application
To: Peter Hall <[email protected]>
Cc: [email protected]
Message-ID: <[email protected]>
Content-Type: text/plain; charset=utf-8
Peter Hall wrote the following on Sat, Oct 01, 2011 at 10:49:31AM +0100:
> I think this sentence isn't right:
>
> "Curried functions are functions that only take one parameter."
>
> The way I understand it, a non-curried function takes only one
> parameter. Currying is syntactic sugar so you don't have to use
> higher-order functions every time you want multiple parameters.
>
> Without currying, if you wanted a function like:
>
> f a b c = 2 * a + b - c
>
> , you'd have to write it something like:
>
> f a = f1
> where f1 b = f2
> where f2 c = 2 * a + b - c
>
> or
>
> f a = (\b -> (\c -> 2*a + b -c))
You are right, I changed the sentence to better reflect wat currying
really is. Thank you for your input.
--
Petar Rado?evi?, Programmer
wunki.org | @wunki
------------------------------
Message: 2
Date: Sun, 2 Oct 2011 00:48:31 +0200
From: Chadda? Fouch? <[email protected]>
Subject: Re: [Haskell-beginners] A post about Currying and Partial
application
To: Peter Hall <[email protected]>, [email protected]
Message-ID:
<CANfjZRbAg52X+Joeq5=bm6xekg6wg0odfrgvzhbxcqkqd8r...@mail.gmail.com>
Content-Type: text/plain; charset=UTF-8
On Sat, Oct 1, 2011 at 2:40 PM, Petar Radosevic <[email protected]> wrote:
> Peter Hall wrote the following on Sat, Oct 01, 2011 at 10:49:31AM +0100:
>> I think this sentence isn't right:
>>
>> "Curried functions are functions that only take one parameter."
>>
>> The way I understand it, a non-curried function takes only one
>> parameter. Currying is syntactic sugar so you don't have to use
>> higher-order functions every time you want multiple parameters.
>>
>> Without currying, if you wanted a function like:
>>
>> ? ? f a b c = 2 * a + b - c
>>
>> , you'd have to write it something like:
>>
>> ? f a = f1
>> ? ? ? where f1 b = f2
>> ? ? ? ? ? where f2 c = 2 * a + b - c
>>
>> or
>>
>> ? ?f a = (\b -> (\c -> ?2*a + b -c))
>
> You are right, I changed the sentence to better reflect wat currying
> really is. Thank you for your input.
Sorry but you are mistaken on the sense of currying. Basically to
curry the function f is to transform it from the type "(a,b) -> c" to
the type "a -> (b -> c)", in other words instead of function from a
cartesian product to a set, you get a function from the first element
of the product to the set of function from the second element of the
product to the original final set. This is a mathematical
transformation that Curry noted was always possible whatever the
function.
In a CS context, this transformation is only possible in languages
that handle functions as first-class data types, Haskell (or the ML
family) is only special in that it encourage you to write every
functions in an already curried style instead of the uncurried fashion
that is used in most other languages. Every single example you give in
your blog is curried, uncurried would be :
> sumTwo :: (Int,Int) -> Int
> sumTwo (x,y) = x + y
and
> f :: (Int,Int,Int) -> Int
> f (a,b,c) = 2 * a + b - c
See the function "curry" and "uncurry" to see that passing from one
style to another can be automated (though only elegantly for two
parameters).
Still it is true that currying functions ease the partial application
of function (at least if your parameters are ordered sensibly).
--
Jeda?
------------------------------
Message: 3
Date: Sun, 2 Oct 2011 08:34:22 +0530
From: Rustom Mody <[email protected]>
Subject: Re: [Haskell-beginners] A post about Currying and Partial
application
To: [email protected]
Message-ID:
<caj+teodlpweco4pzszyomfrdqhygh-z2jnu3jg27fmbuwvd...@mail.gmail.com>
Content-Type: text/plain; charset="iso-8859-1"
On Sun, Oct 2, 2011 at 4:18 AM, Chadda? Fouch? <[email protected]>wrote:
> On Sat, Oct 1, 2011 at 2:40 PM, Petar Radosevic <[email protected]> wrote:
> > Peter Hall wrote the following on Sat, Oct 01, 2011 at 10:49:31AM +0100:
> >> I think this sentence isn't right:
> >>
> >> "Curried functions are functions that only take one parameter."
> >>
> >> The way I understand it, a non-curried function takes only one
> >> parameter. Currying is syntactic sugar so you don't have to use
> >> higher-order functions every time you want multiple parameters.
> >>
> >> Without currying, if you wanted a function like:
> >>
> >> f a b c = 2 * a + b - c
> >>
> >> , you'd have to write it something like:
> >>
> >> f a = f1
> >> where f1 b = f2
> >> where f2 c = 2 * a + b - c
> >>
> >> or
> >>
> >> f a = (\b -> (\c -> 2*a + b -c))
> >
> > You are right, I changed the sentence to better reflect wat currying
> > really is. Thank you for your input.
>
> Sorry but you are mistaken on the sense of currying. Basically to
> curry the function f is to transform it from the type "(a,b) -> c" to
> the type "a -> (b -> c)", in other words instead of function from a
> cartesian product to a set, you get a function from the first element
> of the product to the set of function from the second element of the
> product to the original final set. This is a mathematical
> transformation that Curry noted was always possible whatever the
> function.
> In a CS context, this transformation is only possible in languages
> that handle functions as first-class data types, Haskell (or the ML
> family) is only special in that it encourage you to write every
> functions in an already curried style instead of the uncurried fashion
> that is used in most other languages. Every single example you give in
> your blog is curried, uncurried would be :
>
> > sumTwo :: (Int,Int) -> Int
> > sumTwo (x,y) = x + y
>
> and
>
> > f :: (Int,Int,Int) -> Int
> > f (a,b,c) = 2 * a + b - c
>
>
How would you classify a function of type (Int, Int) -> Int -> Int ?
Likewise if we have a polymorphic foo: Int -> a and we instantiate a to Int
-> Int does foo suddenly get curried?
Which is why it may be better to say this?
Curried and uncurried function are vague ideas, whereas the action of
currying and uncurrying -- as embodied in the standard prelude curry and
uncurry -- are precise and well-defined
See the function "curry" and "uncurry" to see that passing from one
> style to another can be automated (though only elegantly for two
> parameters).
>
> Still it is true that currying functions ease the partial application
> of function (at least if your parameters are ordered sensibly).
>
> --
> Jeda?
>
> _______________________________________________
> 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/20111002/61f81bb7/attachment-0001.htm>
------------------------------
Message: 4
Date: Sun, 2 Oct 2011 00:30:02 -0300
From: Felipe Almeida Lessa <[email protected]>
Subject: Re: [Haskell-beginners] A post about Currying and Partial
application
To: Rustom Mody <[email protected]>
Cc: [email protected]
Message-ID:
<CANd=oggkpumcaocxpknvimlxn2vuvhweboy1g1wggyn2zkc...@mail.gmail.com>
Content-Type: text/plain; charset=UTF-8
On Sun, Oct 2, 2011 at 12:04 AM, Rustom Mody <[email protected]> wrote:
> How would you classify a function of type (Int, Int) -> Int -> Int ?
It's curried. Uncurried would be:
((Int, Int), Int) -> Int
> Likewise if we have a polymorphic foo: Int -> a and we instantiate a to Int
> -> Int? does foo suddenly get curried?
Int -> a is both curried and uncurried. Int -> Int -> Int is just curried.
--
Felipe.
------------------------------
Message: 5
Date: Sun, 2 Oct 2011 10:25:22 +0200
From: Petar Radosevic <[email protected]>
Subject: Re: [Haskell-beginners] A post about Currying and Partial
application
To: [email protected]
Message-ID: <[email protected]>
Content-Type: text/plain; charset="utf-8"
Chadda? Fouch? wrote the following on Sun, Oct 02, 2011 at 12:48:31AM +0200:
> On Sat, Oct 1, 2011 at 2:40 PM, Petar Radosevic <[email protected]> wrote:
> > Peter Hall wrote the following on Sat, Oct 01, 2011 at 10:49:31AM +0100:
> >> I think this sentence isn't right:
> >>
> >> "Curried functions are functions that only take one parameter."
> >>
> >> The way I understand it, a non-curried function takes only one
> >> parameter. Currying is syntactic sugar so you don't have to use
> >> higher-order functions every time you want multiple parameters.
> >>
> >> Without currying, if you wanted a function like:
> >>
> >> ? ? f a b c = 2 * a + b - c
> >>
> >> , you'd have to write it something like:
> >>
> >> ? f a = f1
> >> ? ? ? where f1 b = f2
> >> ? ? ? ? ? where f2 c = 2 * a + b - c
> >>
> >> or
> >>
> >> ? ?f a = (\b -> (\c -> ?2*a + b -c))
> >
> > You are right, I changed the sentence to better reflect wat currying
> > really is. Thank you for your input.
>
> Sorry but you are mistaken on the sense of currying. Basically to
> curry the function f is to transform it from the type "(a,b) -> c" to
> the type "a -> (b -> c)", in other words instead of function from a
> cartesian product to a set, you get a function from the first element
> of the product to the set of function from the second element of the
> product to the original final set. This is a mathematical
> transformation that Curry noted was always possible whatever the
> function.
> In a CS context, this transformation is only possible in languages
> that handle functions as first-class data types, Haskell (or the ML
> family) is only special in that it encourage you to write every
> functions in an already curried style instead of the uncurried fashion
> that is used in most other languages. Every single example you give in
> your blog is curried, uncurried would be :
>
> > sumTwo :: (Int,Int) -> Int
> > sumTwo (x,y) = x + y
>
> and
>
> > f :: (Int,Int,Int) -> Int
> > f (a,b,c) = 2 * a + b - c
>
> See the function "curry" and "uncurry" to see that passing from one
> style to another can be automated (though only elegantly for two
> parameters).
>
> Still it is true that currying functions ease the partial application
> of function (at least if your parameters are ordered sensibly).
Thank you for your explanation. I was also corrected on reddit[1] on the
matter. Since my post is wrong on the subject I have decided chuck it
and write a new one. I'm collecting all the comments people made as we
speak and am going to make good use of them in a post which hopefully
_does_ explain currying.
[1]:
http://www.reddit.com/r/haskell/comments/kxdh7/curry_and_its_partial_application/
--
Petar Rado?evi?, Programmer
wunki.org | @wunki
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 833 bytes
Desc: Signature of Petar Radosevic
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20111002/9da169e7/attachment-0001.pgp>
------------------------------
_______________________________________________
Beginners mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/beginners
End of Beginners Digest, Vol 40, Issue 2
****************************************
