For intro to functional programming

Read SICP. It covers programming from all angles, but naturally gives special consideration to functional programming and closures.

I’m not, so I’d rather not go there – most of the info I found while googling was perl-oriented. Since I am unused to perl syntax, which tends towards brevity (if not outright obfuscation), I’d rather find some clearer explanations somewhere. 🙂

My interest in this is basically academic. I heard what they do, wanted to know more. Pure interest.

I’m reading the book Folger linked to, since I am somewhat familiar with Scheme syntax and it is – parenthetical verbosity aside – quite legible.

I’ll check out the OCaml tutorial too, just to see what it is.

Not too mysterious, but it does seem needlessly over-complicated. The use of different syntax for similar functions can be really confusing, or maybe it’s just that I’m used to how C-derivatives look.
And still, the quite arbitrary rules for ‘;’ and ‘;;’, similar constructs such as tuples, unions, enums or lists each having their own unique delimiter, and usually a different one for definition and for use (|, *, :: and so on) – all these seem quite, well, pointless.

Dynamic Languages

Well, I think this year I actually found myself using closures in Perl, when previously I was getting all glassy-eyed reading about them.

Now, if you don’t like Perl, there are quite a few other dynamic languages that emulate this feature. The obvious one is Javascript. Here’s someone explaining how he implemented a closure in Javascript that’s very similar to what I did in Perl:

http://www.cabezal.com/blog/archives/000607.shtml

He also has a good one-line description of closures, “basically, anonymous inner functions, which retain the surrounding context”. If you have a function that takes a callback/function reference as an argument (like, say, a sort function, or in my case, a function that runs an arbitrary database query and executes my function on each row), you can write the function inline, using variables that are in the calling scope.

It’s basically this sort of useful magic that lets you easily skip over what seem like insurmountable barriers. Or just saves you typing and passing variables around.

Introduction to Anonymous Methods and Higher-Order Procedures in C#

For official details on closures in the next release of C#, see Introduction to Anonymous Methods and Higher-Order Procedures in C# in msdn academic alliance (sounds like an interesting web site).

In Scheme, you only have lexical closure. Called functions always extend the current environment (the list of variables available in the current scope). I always considered that to be the perfect way to program. I assumed C-derivatives didn’t have this feature for historical and technical reasons, not because it wasn’t warranted.

Maybe one day we’ll get a real functional language from Microsoft. 🙂