Dee Language

The D Programming Language is a new programming language defined by WalterBright, who wrote the Zortech C++ (see ZortechCpp) compiler which later became the SymantecCpp compiler and is now the DigitalMars C++ compiler.

The D Language is currently (June 2008) at version 2.0.

See this page on Walter's web site at http://www.digitalmars.com/d/index.html for details of the D language.

Discussion of the D language and its development is on news://news.digitalmars.com in a number of groups:

digitalmars.D
digitalmars.D.dtl
digitalmars.D.bugs
D.gnu

-- JohnFletcher

There is a wiki (Wiki4D):

http://www.prowiki.org/wiki4d/wiki.cgi

and an OS code and project repository

http://dsource.org

I looked at it and I think it is a great language. It is small and simple, OO like Java but native executables (60 KB+), GC, interfaces, templates, closures, enums, dynamic arrays, hashes, switch(string) and a lot more. I have installed a wiki to support Walter's creation: http://www.prowiki.org/wiki4d/wiki.cgi (350+ pages in Aug04). -- HelmutLeitner

According to BjarneStroustrup, there have been at least a dozen languages called D. http://www.research.att.com/~bs/bs_faq.html

Interesting, I was just yesterday thinking that it would be nice to be able to declare functions inside functions to support the simplification of complex if/then/else statements using ExtractMethod refactoring. The idea here is to simplify/clarify the situation where you need to use a large number of local variables in a complex logical comparison and want to keep the expression(s) in the if/then/else statement(s) as short/simple/clear as possible. Without something that allows you to extract a method but still allow access to the local variables of the enclosing function scope, you are left with either passing everything you need into the extracted method (which often confuses things as much as just leaving the messy logical expression in-place), or making all the variables needed in the extracted method(s) instance variables of the enclosing class (confusing, too). Reading the D Language "Quick Comparison" table, I noticed that it supports the notion of "Nested Functions" which allow exactly the behavior desired. Serendipity is an interesting thing... -- GeoffSobering

See NestedScopes.

Being able to nest function definitions is nice for all kinds of reasons (with full-strength LexicalScoping, please), but in the scenario you describe, isn't the code trying to tell you that you're missing one or more classes with responsibility for the logic in the expression? Depending on what the result of the expression is for, maybe Strategy or State would be good patterns to use here. And anyway, isn't the better solution to "the situation where you need to use a large number of local variables in a complex logical comparison" to factor the code so that you only have a small number of local variables involved in a simple logical comparison?