FP is awesome. C# 3.0 does bits of it really well, but I've downloaded F# to play with as well.

There's stuff like, if you've got a function that takes an argument and returns a value, and it takes a while to do it, you can magically create a new function that caches the result for each passed parameter and then returns from the cache where available. Or you can create a class which takes a function as the argument to its constructor, and makes that function execute asynchronously following the new pattern from .NET 3.5.

Seriously, it's awesome.

Yeah, the caching's not particularly ground-breaking, but the ease with which you can implement it is, especially when you realise that you don't need to have written the function you want to add caching to. You write one 15-line function, then you call it on any function you want to use caching and that's it. And you can only do that because you can treat functions as a kind of variable/class arrangement.

Prior to .NET 3.5, the asynchronous implementations of methods were prepended with Begin and End, so you'd have a Fetch function, plus a BeginFetch and an EndFetch. You got a specific return type from the Begin, then you'd call the End to get the actual return value.

In .NET 3.5, you have an implementation of the method ending in Async, plus an event which fires when it finishes executing that passes the return value (or the exception that occurred) in the event arguments. So you'd have FetchAsync and a FetchCompleted event.

So I've made a class where you pass in a function delegate (i.e. pointer) to the constructor, and it has a Completed event and an Invoke method and does basically the same thing but on any method.

Matt: once you get your mind round the basic concept, it's head-fuck free.

It's not proper functional programming in the Haskell or CaML sense, no, because you've got mutable variables and stuff. Mostly it is just having first-class functions, and yes, that's done through delegates and generics which we had in C# 2.0, but the 3.0 compiler has got type inference and lambda syntax and pre-defined Action<T> and Func<T,TReturn> delegate classes and stuff which just make it all much easier to deal with.

For example, you use to have to say

list.Find(delegate(string s){ return s.StartsWith("A"); }

whereas now you can say

list.Find(s => s.StartsWith("A"));

which is much more readable.

Plus, using lambda expressions instead of delegates changes the way you think about them, makes them seem more like variables and things you can throw around the place and store in hash tables and so forth.

I enjoy them similarly. I have no idea what anyone is on about but like to hear their opinions anyway.

Anyway, I wanted you to make up some plausible sounding nonsense.

Well I'm not convinced that the value functioning flops are really worth the VB they are written on.

I mean, ffs, if you're going to do class D sector mounting you might as well do it with an argument contructing delimitted F Class module.

And what's all this nonsense with C# 3.0 obstructing your quads? You might as well shoot a monkey in a barrel as far as I'm concerned.

:?

Hahahahaha. Bees transported by truck :')

Things you never think about.

They should train them to fly there like pigeons.

They should let them fly on aeroplanes for long distances. They could go buzzness class :D

Also, I love that there just happened to be(e) some bee keepers passing at the time to help out :D

If all the bees flew upwards while in a container on the truck it would increase decrease increase the MPG of said truck. /That's/ thinking local, acting global Al Gore.

:Y

I'm having trouble visualising what 12 million bees would be like.

I can't beleive they had chance bee-keepers passing by, but no one had a camera :C