Lambdacamels, slime, and a syphilitic stoat.

1. In which a challenge is thrown, but there is a spanner in the
works!

Haskell suddenly became “important” in the Perl community when Audrey
Tang started to blog about Pugs, the prototype version of the Perl 6
interpreter/compiler. So, when I started looking at Haskell, I did so
with another Perl-monger, larsen, one of the key guys in perl.it. We
worked through some of the exercises in YAHT together when we shared a
flat. Since I moved out we never really got around to doing that, and
I've been working through the exercises in SOE on my own. I realised
that the poor chap was missing out on all the fun! So I thought I could
let him “catch up”, but as that would involve having to give up my
precious copy of “Haskell School of Expression” up, even for a few days,
I panicked slightly.

My alternative was almost a stroke of genius. For a couple of months
I've had “Practical Common
Lisp”
, which larsen lent me, on my bookshelf. I even read some of
it! But I've not gone through in any rigorous way. My challenge to him
was to do what I'm doing with SOE and to blog the exercises.

The “concept” is that at the end of it, I will be able to teach him
Haskell, and he can teach me Lisp. If you need to know both to be a
truly great programmer, perhaps we can both at least be half of one of
those!

The flaw, as it happens, would seem to be that PCL doesn't have
seem to have exercises… (though we seem to remember them existing
somewhere, this was only on a brief scan).

2. In which osfameron squees at slime, and criticises the Perl
debugger and REPL

He has already downloaded SLIME, and mentioned how cool the video with Marco
Beringer
was. I hadn't seen it so he passed me the link. It is
rather nifty, and certainly you can see how features of Lisp like its
regularity make it a joy to parse and manipulate in an IDE. Other
things, like the incremental compilation are interesting, and the depth
of debugging information is astounding.

Compared to this, perl -debug comes off rather badly.
Actually, compared to a drunken, syphilitic stoat, the Perl debugger
might come off badly, but the SLIME package is really rather well put
together. The Perl REPL has several disadvantages, such as not
understanding lexical scopes and not printing out the results of each
call. The cry of “it's hard to use” is probably just an excuse, after
all, if a tool's worth using, you put time into learning it. The
suspicion though is that the Perl debugger isn't really worth learning.
Certain things add to this conviction: for example, I had a vivid memory
that Larry Wall had declared that he was more of a “print statements
kind of guy”. (But, not I can't find it via Google, perhaps I dreamt
it). In any case, there is the fact that generally, Perl programmers,
if they even know about the debugger, tend to use it only for the REPL
(and then moan about it).

At some point, Acme did some work on improving the debugger internals,
documentation and test-suite while creating Devel::ebug,
which looked very cute. In theory at least: I could never get it to
install, and I believe it's now unmaintained and targetting an outdated
version of Catalyst. (Some time passes… some facts are
checked…:
eeek! No, there have been 2 releases over the last
couple of months, yay Acme! And my colleague Mattia Barbon submitted
patches, yay Mattia! I guess I'll have to check it out again at some
point).

Anyway, Lisp absolutely has an impressive toolchain. But the aesthetic
appeal (and, yes, I know that this is influenced by a lack of
familiarity) is still lacking – all those #\UPPER-CASE-SYMBOLS,
especially on the stack traces. Meh. Yes, I know this is stupid, but
it is odd that a language whose algorithms and concepts are so beautiful
should look so fugly.

(Of course, I find (well written) perl code pleasant to read, so I may
not be qualified to pronounce on the aesthetics of programming. OTOH,
this Larry Wall quote I do remember (and Google confirms that I
didn't dream it) “Lisp has all the visual appeal of oatmeal with
fingernail clippings mixed in”.)

3. In which osfameron ponders the virtues of Perl as a functional
programming language, and sings the praises of join

Since the publication of Dominus's seminal Higher Order Perl,
it's hard to deny that Perl enables some Functional Programming
techniques (though you can certainly argue that some of the techniques
are uglier, harder, or less efficient). The three functions in common
use are map, grep, and join.

When Marco creates the convert-to-morse function, he started by
writing a stream to a string, (nice technique! see also IO::Stringy etc.
in Perl) prints a morse character for every character, followed by a
space. He then points out that there's a spurious space after the last
character.

He then starts musing about how to get rid of this and ends up dealing
with the head of the string first, and then doing the rest of the
string, this time prepending the space. While he starts doing this,
every Perl-programmer's muscle in me is screaming, “use join
you fool!”

Anyway, he may be doing it this way for pedagogical purposes, but his
solution surprised me nonetheless. And while I was thinking about it, I
noticed that I hadn't come across join in Haskell either yet,
so I decided to write it.

First of all, I thought it would be:

  > join j = foldr (\left right -> left ++ j ++ right) [] 

which compiles like so

  *Main> :t join  join :: [a] -> [[a]] -> [a]

But there is a problem

  *Main> join "," ["hello","world"]  "hello,world,"

A final comma! Of course as the list is really (“hello” : “world” : [])
the fold will join “world”,”“. Pesky blighter.

I ended up with the slightly less beautiful:

  > join j (v:[]) = v  > join j (v:vs) = v ++ j ++ join j vs

with the same signature. (We could also do join [100] [[1,2], [3,4,5]
for example).

What is the standard Haskellish way of writing join?

(Update: dons on #haskell suggested that the obvious name for this in haskell is "intercalate".  Actually intercalate (so named, because "join" is already taken – for joining monads) would work.  intercalate would be defined as the concatenation of "intersperse".  Steven Ashley suggested this solution too.  (Update: and dcoutts in irc backlog, thanks all!)

    concat $ intersperse "," ["hello", "world"]

on a related note, while I'm hating crappy REPLs, why does ghci make it so bloody hard to do "import Data.List" (in order to get intersperse)?  Interestingly, Perl (5) doesn't have intersperse, as "join" only operates on strings, and it would be nice if it did have the generalised version too.)

4. In which a better REPL for Perl is sighted, and osfameron
bemoans the lyf so short

This morning, via a cpanranting on Rocco Caputo's
Lexical::Persistance, I came across Matt Trout's new-ish Vox blog. As well as an
interesting polemic about Ruby, there's a series
about developing a REPL
(called Devel::REPL, not yet on
CPAN but it's on his bast repo, linked from the blog), which uses that
module to allow variables like my $foo to persist from one line
in the REPL to another. Just like they should!

mst also talks a lot about Moose,
the new Perl object framework which is massive news in a subset of the
modern Perl community. It's quoted as bringing to Perl the things that
you would otherwise have to flee to Ruby for. Things like declarative
class generation and function argument unrolling (in an extension iirc).
And (as this post is already too long), “much much more”.

All of which reminds me that, as well as spending time learning Haskell,
I should really keep up to date with learning Perl. Which I
will obviously do in my proverbial Copious Free Time!