Am Samstag, 25. Oktober 2008 15:57 schrieb Glurk:
I'm using WinHugs - do you get them to work in some other environment ?
Did you give a type signature for these? Then you would of course have to include the context Eq b, since (==) is
used.
If you don't give any type signatures, all above versions should work in all environments, otherwise it would be a serious bug.
OK, now I'm getting somwhere ! :)
I tried it with GHCi, and it works ! ...but only after disabling the monomorphism restriction !
Oh yes, the dreaded MR I forgot.
It offered another alternative, which was to give a type definition.
So, I tried :-
matches :: Eq a => a -> [a] -> [a] matches = filter . (==)
hm :: Eq a => a -> [a] -> Int hm = (length .) . matches
in Hugs, and that also worked :)
I'm still struggling to come to grips with how it is actually working... I was thinking that this pointfree style was to make things simpler, more readable and understandable...but now I'm not so sure !
Sometimes pointfree style is clearer and more readable, sometimes it makes things obscure. Get some experience writing both, pointfree and pointful versions, to develop a feeling when to write pointfree and when not (and when to use mixed style, e.g. "hm x = length . matches x" might be clearer).
If it's not a simple case (f.g.h etc) I might just stick with putting the parameter names in. At this point, brackets and multiple dots like this don't really make things clearer to me (Not to mention John's post below, with 3 consecutive dots ! I'm really having trouble with that one !). Of course, a lot of this is due to my lack of understanding - I'll keep experimenting and trying to learn :)
In general though, do people find this style clearer ? I'd be interested to know what other people prefer.
Thanks for all the help :)
If you compose single-argument functions, the pointfree composition = f . g . h seems clearer than composition x = f . g . h $ x , a case like howMany, howMany = (length .) . matches is sufficiently clear either way (less if written ((.) . (.)) length matches), but beyond that supplying arguments is desirable. Would you prefer to read composition = ((.) . (.) . (.) . (.) . (.)) func thing composition = ((((func .) .) .) .) . thing composition a b c d = func . thing a b c d or composition a b c d e = func $ thing a b c d e ? IMO, the last two are okay, the first is baaad, the second bad unless in special circumstances.