Hi list, Is there a syntax in Haskell for partial application that would be something like this the following ? f a b c d = a +b+ c+ d g = f _ 1 2 3 or the only way to do it is like below ? g = (\x -> f x 1 2 3) Also, hlint complains about top-level functions without type even if they are not exported out of the corresponding module. Is is really bad style not put type signatures in all top-level functions ? I really like the fact that haskell takes care of the type signatures for me. best, Miguel http://www.friendlyvirus.org/miguelnegrao/
On Mon, Dec 03, 2012 at 12:28:08PM +0000, Miguel Negrao wrote:
Hi list,
Is there a syntax in Haskell for partial application that would be something like this the following ?
f a b c d = a +b+ c+ d
g = f _ 1 2 3
or the only way to do it is like below ?
g = (\x -> f x 1 2 3)
Yes, a lambda is the only way to do it.
Also, hlint complains about top-level functions without type even if they are not exported out of the corresponding module. Is is really bad style not put type signatures in all top-level functions ? I really like the fact that haskell takes care of the type signatures for me.
Yes, it is bad style. Let me give you two reasons why I always encourage putting type signatures on all top-level functions. Whether they are exported or not really makes no difference. 1. Writing the type signature for a function *first*, before implementing it, really helps a LOT in clarifying things in your own mind. If you cannot write down the intended type of a function then you do not understand what it is supposed to do. If you do not understand what it is supposed to do then how do you expect to be able to implement it? 2. Suppose you make a mistake when implementing a function. If you don't give a type signature, it's possible that GHC will infer some type for it anyway (but not the type you intended!). Now you will not get an error until further down the line when you use that function somewhere else. And what's more, the error will not tell you anything about the real problem. It will just say "X does not match Y on line 297" and you will have to do a lot of work to figure out that the real problem is that you messed up in implementing function foo on line 43. But if you had put a type signature on foo in the first place, you would have gotten an error immediately. -Brent
Brent Yorgey
On Mon, Dec 03, 2012 at 12:28:08PM +0000, Miguel Negrao wrote:
Is there a syntax in Haskell for partial application that would be something like this the following ?
f a b c d = a +b+ c+ d
g = f _ 1 2 3
or the only way to do it is like below ?
g = (\x -> f x 1 2 3)
Yes, a lambda is the only way to do it.
In the case where you have fewer (specifically two) variables, you can also use `flip`:: f a b = a / b -- g = f _ 2 can be written as: g = flip f 2 -Keshav
g = (\x -> f x 1 2 3)
Yes, a lambda is the only way to do it.
This is not exactly the same thing, but if you have a function that accepts
only two arguments, you can use `flip` to partially apply with the other
one:
f a b = a ++ b
g = (flip f) "xyz"
g "abc" -- "abcxyz"
To extend that to functions with more parameters, you'd have to create an
equivalent of `flip` for each arity, and the desired permutations might be
more complicated than just reversing them. Still, in the two-argument case,
flip can often be cleaner than a lambda.
Peter
On 3 December 2012 12:53, Brent Yorgey
On Mon, Dec 03, 2012 at 12:28:08PM +0000, Miguel Negrao wrote:
Hi list,
Is there a syntax in Haskell for partial application that would be something like this the following ?
f a b c d = a +b+ c+ d
g = f _ 1 2 3
or the only way to do it is like below ?
g = (\x -> f x 1 2 3)
Yes, a lambda is the only way to do it.
Also, hlint complains about top-level functions without type even if they are not exported out of the corresponding module. Is is really bad style not put type signatures in all top-level functions ? I really like the fact that haskell takes care of the type signatures for me.
Yes, it is bad style. Let me give you two reasons why I always encourage putting type signatures on all top-level functions. Whether they are exported or not really makes no difference.
1. Writing the type signature for a function *first*, before implementing it, really helps a LOT in clarifying things in your own mind. If you cannot write down the intended type of a function then you do not understand what it is supposed to do. If you do not understand what it is supposed to do then how do you expect to be able to implement it?
2. Suppose you make a mistake when implementing a function. If you don't give a type signature, it's possible that GHC will infer some type for it anyway (but not the type you intended!). Now you will not get an error until further down the line when you use that function somewhere else. And what's more, the error will not tell you anything about the real problem. It will just say "X does not match Y on line 297" and you will have to do a lot of work to figure out that the real problem is that you messed up in implementing function foo on line 43. But if you had put a type signature on foo in the first place, you would have gotten an error immediately.
-Brent
_______________________________________________ Beginners mailing list Beginners@haskell.org http://www.haskell.org/mailman/listinfo/beginners
participants (4)
-
Brent Yorgey -
Keshav Kini -
Miguel Negrao -
Peter Hall