[Haskell-beginners] A little explanation!

[David Thomas]

I think this one is most clear removing only one point:

elementAt_w'pf n = last . take (n + 1)

No line noise, simple composition of two functions.  Extremes of point
free style are frequently harmful, but understanding it is worthwhile
and sensibly limited application can improve readability.  I'm not
sure I'd call the example here "extreme" but it's certainly
approaching it (in terms of what I find easily readable).


On Wed, Apr 30, 2014 at 11:16 AM, Kyle Murphy <orclev at gmail.com> wrote:
> On the point of it being "retarded" there's some merit to that in that it's
> written in point-free (or as some joking call it, pointless) style. The idea
> is to remove the explicit variables and so the functions are re-arranged and
> composed such that all the variables come at the end of the statement and
> you're left with nothing but a chain of functions at the start (which can
> sometimes be easier to understand since it's just function composition). The
> downside, as you've seen is that it often hurts readability and so there are
> some that are strongly opposed to point-free style. If used carefully, and
> things are broken into smaller easier to understand chunks (via for instance
> let or where clauses) it can still be readable even using point-free style,
> but it's really dependent on both the skill of the person writing the
> statement, and the familiarity and skill of the person reading the
> statement. When in doubt about legibility it's better to avoid point-free
> style, in particular if you start having to do strange things like apply the
> (.) operator to itself (E.G. "(f .) . g" or similar) you're probably being
> to clever for your own good. I wouldn't go so far as to say you should
> *never* use point-free style, but you should seriously consider if you're
> trying to just be clever and show off, or if it really is making the
> statement simpler to understand via more clearly showing how the functions
> are composed.
>
>
> -R. Kyle Murphy
> --
> Curiosity was framed, Ignorance killed the cat.
>
>
> On Wed, Apr 30, 2014 at 1:19 PM, Michael Orlitzky <michael at orlitzky.com>
> wrote:
>>
>> On 04/30/2014 11:29 AM, Gilberto Melfe wrote:
>> > Hello everybody !
>> >
>> > Could someone explain me exactly how this function works?
>> >
>> > elementAt_w'pf = (last .) . take . (+ 1)
>> >
>> > It's a posted solution to: 99 Haskell problems, problem 3.
>> >
>> > I'm having trouble with the "(last .) ." thing!
>> >
>>
>> It's not your fault, that solution is retarded. Once you remove all of
>> the intentional obfuscation, it looks like,
>>
>>   elementAt_w'pf n xs = last (take (n + 1) xs)
>>
>> which is easy to understand. You can un-retard it step-by-step:
>>
>>     elementAt_w'pf = (last .) . take . (+ 1)
>>
>> <=> elementAt_w'pf n = ((last .) . take . (+ 1)) n
>>
>>                      = (last .) ((take . (+ 1)) n)
>>
>>                      = (last .) (take (n + 1))
>>
>>                      = last . (take (n + 1))
>>
>> <=> elementAt_w'pf n xs = (last . (take (n + 1))) xs
>>
>>                         = last (take (n + 1) xs)
>>
>> All I've used above is the precedence of the function composition
>> operator, and the fact that (f . g) x = f (g x).
>> _______________________________________________
>> Beginners mailing list
>> Beginners at haskell.org
>> http://www.haskell.org/mailman/listinfo/beginners
>
>
>
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://www.haskell.org/mailman/listinfo/beginners
>