G'day all.
Quoting aditya siram <aditya.si...@gmail.com>:
I'm a little confused about this too. I've seen many functions defined like:
f x = (\s -> ...)
which is a partial function because it returns a function and is the same as:
f x s = ...
Off the top of my head the State monad makes extensive use if this
style. Is this bad?
It's not inherently bad style.
In the State/Reader monads, the passed-in parameter is part of the type:
type State s a = s -> (s,a)
f :: Foo -> State s a
Since f has only one argument according to its type signature, it
makes sense to give it only argument in its rules as well:
f x = \s -> ...
This re-enforces the fact that s is an implementation detail of State.
It is an error in Haskell to have multiple rules for a function with
different arities. So this, for example, is illegal:
f True = length
f False [] = 3
f False (_:_) = 2
If there were a good reason for writing the first rule in a point-free
manner, it would be perfectly reasonable to rewrite this using an
explicit lambda.
There are also performance issues which may be relevant. GHC doesn't
break up lambdas to do let-floating, so if that's what you want, you
may need to express it manually:
data TreeSet a
= Null
| Singleton a
| Doubleton a a
| Branch a TreeSet TreeSet
elem :: (Ord a) => TreeSet a -> a -> Bool
elem Null
= \p -> False
elem (Singleton p1)
= \p -> p == p1
elem (Doubleton p1 p2)
= \p -> p == p1 || p == p2
elem (Branch p' l r)
= let elem_l = elem l
elem_r = elem r
in \p -> if p < p' then elem_l p else elem_r p
Like all situations where you've got more than one way to express
something, which one you pick depends on what you're trying to say.
Cheers,
Andrew Bromage
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
