DMD 1.039 and 2.023 releases

[Yigal Chripun]

bearophile wrote:
> Bill Baxter:
>> To me it's hard to see those variable declarations as being anything
>> other than scoped to the blocks they're in.
>> So all I'm saying is if we could have some different delimiters for
>> non-scope blocks then it might be nice, and make it easier to see when
>> scopes are ending and when they are not.
>
> *Now* I understand, and I see your point.
> It's the usual problem: ASCII doesn't have enough ways to represent containers and delimiters :-)
>
> So if this is your original code (I have improved your indentations and improved readability a little):
>
> void doSomething(T)(int i) {
>      if (i == 0) {
>          static if (is(T == A)) {
>              A.SomeAlias x;
>          } else static if(is(T == B)) {
>              B.SubType x;
>          } else {
>              T x;
>          }
>
>          x = ... whatever
>     }
>     else
>          int y = x;
> }
>
>
> This can be the new version following your idea:
>
> void doSomething(T)(int i) {
>      if (i == 0) {
>          static if (is(T == A)) ::
>              A.SomeAlias x;
>          :: else static if(is(T == B)) ::
>              B.SubType x;
>          :: else ::
>              T x;
>          ::
>
>          x = ... whatever
>     }
>     else
>          int y = x;
> }
>
>
> But the problem is that :: don't have a head and tail, so the code is even less easy to read.
>
> This version uses (* ... *), used in Pascal to denote comments:
>
> void doSomething(T)(int i) {
>      if (i == 0) {
>          static if (is(T == A)) (*
>              A.SomeAlias x;
>          *) else static if(is(T == B)) (*
>              B.SubType x;
>          *) else (*
>              T x;
>          *)
>
>          x = ... whatever
>     }
>     else
>          int y = x;
> }
>
>
> I don't like that too, even if it's a bit better than the version with ::.
>
> Two other possibilities:
>
> void doSomething(T)(int i) {
>      if (i == 0) {
>          static if (is(T == A)) {|
>              A.SomeAlias x;
>          |} else static if(is(T == B)) {|
>              B.SubType x;
>          |} else {|
>              T x;
>          |}
>
>          x = ... whatever
>     }
>     else
>          int y = x;
> }
>
>
> void doSomething(T)(int i) {
>      if (i == 0) {
>          static if (is(T == A)) {#
>              A.SomeAlias x;
>          #} else static if(is(T == B)) {#
>              B.SubType x;
>          #} else {#
>              T x;
>          #}
>
>          x = ... whatever
>     }
>     else
>          int y = x;
> }
>
> I don't think lot of people will appreciate those.
> So the lack of different block delimiters may make this problem have no better solution.
>
> Bye,
> bearophile

in C# they use the same syntax as the c pre-processor for conditional 
compilation and such even though C# doesn't have a pre-processor and the 
syntax is interpreted by the compiler. the above would be something like:

  void doSomething(T)(int i) {
       if (i == 0) {
           #if (is(T == A))
               A.SomeAlias x;
           #elif (is(T == B))
               B.SubType x;
           #else
               T x;
           #endif

           x = ... whatever
      }
      else
           int y = x;
  }

D can always revert to this kind of syntax for compile time code.