Re: lambda, ->, haskell, and so on

As background: I've been doing Ruby full-time for about four years,
until about two months ago, when I started doing Haskell full-time
(though I still do a day or so a week of Ruby).

On 2008-05-09 00:33 +0900 (Fri), ara.t.howard wrote:

> well, as michael pointed out, it's already there an i that ruby has shown 
> itself to be moving more and more into the functional realm....

Not really so much, no.

> ...but feel that the functional languages should take a page from ruby
> not the other way around - ruby's syntax is easily among the prettiest
> on any existing multi-purpose language.

I'd disagree.

Ruby is somewhat pretty, but it's got big consistency problems,
especially compared to, say, Smalltalk, Haskell, or whatever.

And changing Haskell to be more like Ruby, as one example, would make a
lot of typical FP techniques more difficult.

This all has little bearing on the arrow syntax, however. It seems to
make little difference (other than asthetic and in terms of generating
a parser) in this situation, and it's not even all *that* terribly
common in Haskell anyway, where programmers tend to be far more reliant
on building new functions with combinators and passing them around as
first-class values.

As a simple example of Haskell's expressive power, let's look at a
polymorphic (but statically type checked) function to sort pairs of
things, but with the order of the second part of the pair taking
precedence over the first:

    sortSndFst [(1,5),(3,3),(2,3),(0,5),(5,0)]
    -- result: [(5,0),(2,3),(3,3),(0,5),(1,5)]

You could define it like this:

    sortSndFst list =
        sortBy (\a b -> case compare (snd a) (snd b) of
                             LT -> LT
                             GT -> GT
                             EQ -> compare (fst a) (fst b))
	       list

but a much more functional style is a quarter the size (I've added extra
parens for evaluation order clarity, though they could all be replaced
by a single '$' after 'sortBy':

    sortSndFst = sortBy ((comparing snd) `mappend` (comparing fst))

This makes use of currying, passing functions into other functions to
generate new functions, a Monoid for control flow, and it's small enough
to be so obviously correct (if it passes the typechecker) that I don't
even need to bother with a type declaration (it's inferred) much less a
unit test. (Oh, and not one lambda. :-))

Much of this stuff can also be done in Ruby, but not in anywhere near
as clean or reliable a way, though I'd be very pleased if Ruby moved in
that direction.

cjs
-- 
Curt Sampson       <[e-mail]>        [phone]   
Mobile sites and software consulting: http://www.starling-software.com