great, thanks! what a shame it is not featured in C#, anonymous methods seem too inpractic for me.

How is an anonymous method too impractical? Isn't it exactly what you described?

You mean like this?

var m_sContent = string.Join("\n", sqlreader.Select(x => Compose(x.odID, x.ontorequest, x.wouldLike)));

//Or this?

var m_sContent = string.Join("\n", sqlreader.Select(x => string.Format("constblaconstblacnsta{0}ocnstbla{1}asfloaksf{2}constbla", 
               x.odId, x.ontorequest, x.wouldLike)));

//Or this?

Func<SQLElement,string> compose = x => string.Format("{0} {1} {2}", x.odId, x.ontorequest, x.wouldLike));
var m_sContent = string.Join("\n", sqlreader.Select(compose));
 

Seriously. C# has got you covered.

public void Instructions()
{
    string thelogiclyvarying="constblaconstblacnsta"+ id+"ocnstbla"+onto+"asfloaksf"+wouldlike+"constbla"; /* those variables on right side do not exist and exist and vary in cycle */
    // And all the magic happens in the next line...
   Func<string, string, string, string> compose = (id, onto, wouldlike) =>
   {
      return "constblaconstblacnsta"+ id+"ocnstbla"+onto+"asfloaksf"+wouldlike+"constbla"; 
   }

   while (sqlreader.Read())
   {
      m_sContent += compose(sqlreader["odID"],sqlreader["ontorequest"],sqlreader["wouldlike"]);
   }
}

Lambda is what we get in C++11, and aside from the somewhat odd syntax it does everything you're asking. In Pre-C++11 days you could accomplish the same by nesting a functor class, although the generally-large amount of boiler-plate code needed to do so was such that it was often impractical--works exactly the same though, I once had to backport some early C++11 code to a compiler that didn't support lambda syntax, so I became quite familiar with that boilerplate unfortunately.

I'd like to have plain old local functions though, and lots of languages have them (D is the only C-like language with direct support). Its not even that they're all that useful--most of the places you'd use them you want a lambda anyway--its more a matter of orthogonality to me, and of giving programmers the means to manage scope and such as they see fit.

Lambda is what we get in C++11, and aside from the somewhat odd syntax it does everything you're asking. In Pre-C++11 days you could accomplish the same by nesting a functor class, although the generally-large amount of boiler-plate code needed to do so was such that it was often impractical--works exactly the same though, I once had to backport some early C++11 code to a compiler that didn't support lambda syntax, so I became quite familiar with that boilerplate unfortunately.

I'd like to have plain old local functions though, and lots of languages have them (D is the only C-like language with direct support). Its not even that they're all that useful--most of the places you'd use them you want a lambda anyway--its more a matter of orthogonality to me, and of giving programmers the means to manage scope and such as they see fit.

C++11 lambda does, of course, have its slightly funky syntax and semantics though, though it has been done worse... (*cough* Java *cough*).

granted, I suspect the absence of GC may play into this some (as well as keeping it parsable).

as for lambda vs nested functions:

for a lot of languages where lambdas are supported, the compiler is smart enough at least to generally figure out where a cheaper (non-closure) nested-functions can be used instead.

or, if you mean the ability to declare nested functions like normal functions/methods (vs having to use a variable and store a lambda into it), then yes, this is a useful feature.