Functions as return values

[=?Utf-8?B?QmVu?=]

Hi all,
I'm trying to understand the concept of returning functions from the
enclosing functions. This idea is new to me and I don't understand when and
why I would need to use it.
Can someone please shed some light on this subject?

Thanks a lot,

Ben

[Duggi]

On Aug 11, 11:24*pm, Ben <B...@discussio ns.microsoft.co mwrote:

Hi all,
I'm trying to understand the concept of returning functions from the
enclosing functions. This idea is new to me and I don't understand when and
why I would need to use it.
Can someone please shed some light on this subject?

Thanks a lot,

Ben

"returning functions from the enclosing functions"

Ummm... Which concept you are talking about???

-Cnu

[Peter Duniho]

On Mon, 11 Aug 2008 11:24:08 -0700, Ben <Be*@discussion s.microsoft.com >
wrote:

Hi all,
I'm trying to understand the concept of returning functions from the
enclosing functions. This idea is new to me and I don't understand when
and
why I would need to use it.
Can someone please shed some light on this subject?

Do you mean "anonymous methods"? If so, that's a sub-set of a broader
topic related to delegate types.

The anonymous methods themselves are, IMHO, useful because they allow
implementation details to remain close to where they are used, and can
even avoid the need to define a new class for the purpose holding data
specific to the implementation (see "variable capturing"). But much of
the usefulness is just the same as for delegates generally.

Jon Skeet has a nice article on delegates generally here:
http://yoda.arachsys.com/csharp/events.html

He's also written an article on "closures" that discusses the concept,
albeit in the context of lambda expressions (which can be used in ways
similar to anonymous methods). Here's a link to that:
http://csharpindepth.com/Articles/Ch.../Closures.aspx

It's difficult in the context of a newsgroup to provide a complete
discussion that answers a question as broad as yours. Hopefully the above
links will help. If you have more specific questions remaining after
reading those articles, please feel free to post those here and we can try
to elaborate.

If the above doesn't seem to be addressing your question, then maybe you
can be more specific about what you're asking. The phrase "concept of
returning functions from the enclosing functions" doesn't literally
describe anything in C# at all, so I've made some inferences regarding
what you really mean. If I've made an incorrect assumption, you may want
to try to rephrase your question in a more specific way (including code
examples if necessary).

Pete

[=?UTF-8?B?R8O2cmFuIEFuZGVyc3Nvbg==?=]

Ben wrote:

Hi all,
I'm trying to understand the concept of returning functions from the
enclosing functions. This idea is new to me and I don't understand when and
why I would need to use it.
Can someone please shed some light on this subject?

Thanks a lot,

Ben

What you would actually return from the method would be a delegate.

Returning delegates from a method is not so common, but a delegate is a
type that can be used for the return value just like any other type.
Delegates are most commonly used by events, but they are also used in
other ways. The Array.Sort method for example has some overloads that
takes delegates, which is used to compare the items when they are sorted.

You can make a method that compares two strings in a special way:

public static int CompareIgnoreCa se(string x, string y) {
return string.Compare( x, y, true);
}

Then you can use the name of the method to send a delegate to the Sort
method:

Array.Sort<stri ng>(myStringArr ay, CompareIgnoreCa se);
Or using an anonymous method:

Array.Sort<stri ng>(myStringArr ay, delegate(string x, string y) { return
string.Compare( x, y, true); } );

Or even a lambda expression if you are using C# 3:

Array.Sort<stri ng>(myStringArr ay, (x, y) =string.Compare (x, y, true));
To expand this in the direction of your original question, you could
have a method that returns different delegates depending on how you want
to sort:

public static Comparison<stri ngGetComparer(b ool ignoreCase) {
if (ignoreCase) {
return delegate(string x, string y) {
return string.Compare( x, y, true);
};
} else {
return delegate(string x, string y) {
return string.Compare( x, y);
};
}
}

Calling the method would return a delegate, which you then can use in
the call to the Sort method:

Array.Sort<stri ng>(myStringArr ay, GetComparer(tru e));

You can of course call the delegate directly also:

int result = GetComparer(tru e)("Peter", "Paul");

Or store it in a variable, and call it:

Comparison<stri ngcomp = GetComparer(tru e);
int result = comp("Jack", "Jill");

--
Göran Andersson
_____
http://www.guffa.com

[Pavel Minaev]

On Aug 11, 10:24*pm, Ben <B...@discussio ns.microsoft.co mwrote:

Hi all,
I'm trying to understand the concept of returning functions from the
enclosing functions. This idea is new to me and I don't understand when and
why I would need to use it.
Can someone please shed some light on this subject?

First of all, I would recommend to read the Wikipedia article on
closures:

http://en.wikipedia.org/wiki/Closure_(computer_science)

While it doesn't have any C# examples, it does have some JavaScript
ones (oh, the pains I had to go through to put them there together
with Scheme in spite of people claiming that JS closures are not
"pure"...), which is reasonably close, and hopefully understandable
enough. The article does have some examples of functions returning
functions.

As for the more practical usage - for example, you can use such a
pattern when you have several controls which have mostly similar, but
yet subtly different event handlers (particularly so when the
difference is in signatures, return types, or types of local
variables). In this case, it makes sense to have a factory method that
can generate and return various versions of the same event handler,
using anonymous delegate.

[=?Utf-8?B?QmVu?=]

Thank you all for the kind replies,

and sorry for the confusion. Yes, what I meant was returning anonymous methods
as return values of methods (which is done in .net using delegates).
I will take a look at the various links that you guys have kindly provided and
hopefully I will have a better grasp of this whole closure subject.

Thanks again for everyone,

Ben

[=?UTF-8?B?R8O2cmFuIEFuZGVyc3Nvbg==?=]

Ben wrote:

Thank you all for the kind replies,

and sorry for the confusion. Yes, what I meant was returning anonymous methods
as return values of methods (which is done in .net using delegates).
I will take a look at the various links that you guys have kindly provided and
hopefully I will have a better grasp of this whole closure subject.

Thanks again for everyone,

Ben

Do you mean the specific case of returning an anonymous method as a
delegate, or returning a delegate in general? To return a delegate from
a method it doesn't have to come from an anonymous method.

Example:

public static Comparison<stri ngGetComparison (bool returnAnonymous ) {
if (returnAnonymou s) {
// this returns an anonymous method as a delegate:
return delegate(string x, string y) { return string.Compare( x, y) };
} else {
// this returns a named method as a delegate:
return CompareStrings;
}
}

public static int CompareStrings( string x, string y) {
return string.Compare( x, y);
}

--
Göran Andersson
_____
http://www.guffa.com

[=?Utf-8?B?QmVu?=]

Yes, you're right Goran. Since C# 2.0 we can have both anonymous methods and
delegates as return values of methods, and we might see more developers using
anonymous methods/lambdas because C# 2.0/3.0 allows it.
What I meant was returning a delegate in general. It's just that we are now
starting to see this kind of way of programming more and more because the
language offers some additional stuff like closures, but my question id
really simple (and kind of silly, i know :)). I can understand when a method
returns an int, a class, an array etc. but a function? I don't get this
simple idea of returning functionality :) When would I want to return
functionality?

Thanks again,

Ben

[Jon Skeet [C# MVP]]

On Aug 13, 11:53*am, Ben <B...@discussio ns.microsoft.co mwrote:

Yes, you're right Goran. Since C# 2.0 we can have both anonymous methods and
delegates as return values of methods, and we might see more developers using
anonymous methods/lambdas because C# 2.0/3.0 allows it.
What I meant was returning a delegate in general. It's just that we are now
starting to see this kind of way of programming more and more because the
language offers some additional stuff like closures, but my question id
really simple (and kind of silly, i know :)). I can understand when a method
returns an int, a class, an array etc. but a function? I don't get this
simple idea of returning functionality :) When would I want to return
functionality?

One use is to defer execution of something. "Give me something I can
call at a later date to open the relevant file" or "Give me something
I can call at any time to compare items in an appropriate way". If you
think of a delegate type as being like a single-method interface, that
may help.

Another use I've recently blogged about is improving the performance
of reflection: you can (with care) create delegates from MethodInfo
objects:
http://msmvps.com/blogs/jon_skeet/ar...delegates.aspx

(Warning: there's some hairy stuff in there.)

Jon

[=?Utf-8?B?QmVu?=]

Jon,

Thank you very much for your reply.
The tip about thinking of delegates as being like single method interfaces
was great. And I'm gonna take a look at the link you provided.

P.S.
You're one of my favorite authors, right up there with Jeffrey Richter and
Andrew Troelsen (You can make hard stuff look simple and not the other way
around). How do you know all this stuff? :)