I said it was harder

"Update: I made a major goof-up here."

"In C# 2.0, with anonymous delegates, everything I've written is unnecessary.

something like this:

No, something like this:

someCollection collect: [:each | each applyFunction]

Even in current C# it is only:

	ArrayList myList = new ArrayList;

	foreach (IMyStuff item in listArg) {
		myList.Add(funDelegate(item));
	}

	return myList;

Comment by Michael Lucas-Smith

That's still too much typing. To compare:

myList := OrderedCollection new.
listArg do: [:item | myList add: item funDelegate].
^myList

listArg collect: [:item | item funDelegate]

I agree that in C#, it sucks...now. C# 2.0 makes it easier as do C-Omega (the research language). This is a limitation of the language rather than the .NET runtime. But the way C# makes you jump through hoops to do something as simple as Map is just ridiculous

In Haskell, it's:

map applyFunction someCollection

Hmm, that type checking is really coming in handy! ;-)

Michael,

No fair! All you have done is hide the steps behind another function (part of the Smalltalk image I understand). I can do that too!

My conclusion at least is no significant advantage to Smalltalk (on this one).

In case you were replying to me (Michael is overloaded :o):

I was just trying to show that Sriram's "problem" is unrelated to type systems per se. It's rather a problem of C#'s (un)expressiveness. The second sentence was just a joke ;-)

(This specific example seems more suited to functional style (I don't have to write \each -> applyFunction each) but I can simply write applyFunction -- would that work in a Smalltalk with first-class messages, or am I confused?), but I didn't intend to compare that against blocks or anything -- not up to that challenge yet, still recovering from the flu :o)