Jeremy D. Miller -- The Shade Tree Developer

Your Ruby example is close, but blocks are always the last parameter to a method, so the binding parse-wise has them appearing outside of the parenthesis. Also, parameters passed to a block are defined in the block. So:

systems.find() { |system| system.name == name }

(Parenthesis used for clarity)

In your example Ruby would probably see the opening curly-brace and expect a hash-literal instead of a block.

This syntax is consistent with lambdas (a function to declare a block) and Procs (a class representing a block), so it gets reinforced and makes it a little easier to remember.

So we could also write it like:

condition = lambda { |system| system.name == name }

systems.find(&condition) # Use the "&" to indicate a block-argument.

Or:

condition = Proc.new { |system| system.name == name }

systems.find(&condition)

Of course Array#find just returns the item you're looking for. Which is known ahead of time in this case. So I'm assuming this is just a simplified example. If not, I would suggest using Array#index or Array#include? instead.

A couple things to keep in mind with regards to the Prototype library: It's iterators are very slow. Hopefully most of the time it shouldn't matter. When it does, stick to a traditional for() loop though. Also, if you're iterating over hashes like so:

for(var key in something) {

 alert(key);

}

You'll get the decorated methods too. Which is no fun. You'll want to use this instead:

for(var key in something) {

 if(typeof something[key] == 'function') { continue; }

 alert(key);

}

Anyways, nice post. :-)

It's a bit cleaner with a generic, since you don't have to supply the _systems parameter:

_systems.Find(delegate(ISystemUnderTest system)

                        {

                           return string.Compare(system.Name, systemName, true) == 0;

                        }

                    );

Thank god for Resharper's formatting of these things :)

I started using this syntax too a couple of weeks ago... But I'm still not sure what it's called.. Is the .Find(delegate.. sytax a closure, or just a delegate?

I hope I've got the syntax right. I don't have a Windows machine to test with right now:

<code>

public void Main() {

Console.WriteLine("c# supports closures? {0}", (GetClosure()() == true));

}

Delegate GetClosure() {

bool capture = true;

return delegate() {

return capture;

};

}

</code>

So, what determines a Closure is wether it captures the value of variables that would have otherwise gone out of scope.

C# 3.0 it becomes nicer:

return Array.Find<ISystemUnderTest>(_systems,

                        system => system.Name == systemName);

Can't wait :)

Actually, I think my c# example is off WRT the return statement.

Maybe it's just me, but I *HATE* the new lambda syntax in c#3. It's inflexible. In Ruby you can have a block of any length, but c#3's syntax limits you to a single expression as far as I can tell. Which is more of a nifty toy feature than anything since you could just do the same thing with Enumerable methods.

So now, in addition to event, Delegate, and delegate we get a new syntax for lambdas. Ruby does all this with one syntax. Or Python. Or pick-your-language. Messy.

Heh, I wish. I've been lucky enough to code in Ruby and .NET in spurts, but I spend 90% of my time these days trying to bend ASP Classic to my will. At least at work. :-)

I agree it's nice to c# getting extra features though. I'm just a little concerned about the fragmentation.

I love delegates & anonymous methods! really! you could create great "templates" and provide some high-level API for your developers which really cuts down repetitive code. I even did a lecture in the C# User Group (in Israel) about this subject:

http://www.lnbogen.com/SlidesDemosFromMyCodeTemplatingPresentation.aspx