Since Walter converted his game I thought I should do mine - good reason to play with D.

I've just tried to use the 'with' statement, and now I'm disappointed.

Firstly I tried made the mistake of putting '.' infront of the members I was refering to (aka VB) - fail.

OK so I learnt that its just a way of changing the search scope in the symbol table.

But then I discover that it only works for Objects not structs (or
interfaces I assume).

Walter,  please change the syntax to include the '.'; that way one can refer to '.x' and 'x' as two different things.

And please, please make it work with anything that uses the '.' operator.

A trite example:

struc A {
    int x;
    int y;
    func1() { return x + y; }
}

int f2(int x, int y)
    A a;

    with(a) {
        .x = x;
        .y = y;
        return .func1();
    }
}

Of cause this stuffs up the module scope operator, so maybe it should be '::'.



"Scott Egan" <scotte@tpg.com.aux> wrote in message news:c706ro$5s9$1@digitaldaemon.com...
> Since Walter converted his game I thought I should do mine - good reason
to
> play with D.
>
> I've just tried to use the 'with' statement, and now I'm disappointed.
>
> Firstly I tried made the mistake of putting '.' infront of the members I
was
> refering to (aka VB) - fail.
>
> OK so I learnt that its just a way of changing the search scope in the symbol table.
>
> But then I discover that it only works for Objects not structs (or
> interfaces I assume).
>
> Walter,  please change the syntax to include the '.'; that way one can
refer
> to '.x' and 'x' as two different things.
>
> And please, please make it work with anything that uses the '.' operator.
>
> A trite example:
>
> struc A {
>     int x;
>     int y;
>     func1() { return x + y; }
> }
>
> int f2(int x, int y)
>     A a;
>
>     with(a) {
>         .x = x;
>         .y = y;
>         return .func1();
>     }
> }
>
>
>

Scott Egan wrote:

>Since Walter converted his game I thought I should do mine - good reason to
>play with D.
>
>I've just tried to use the 'with' statement, and now I'm disappointed.
>
>Firstly I tried made the mistake of putting '.' infront of the members I was
>refering to (aka VB) - fail.
>
>OK so I learnt that its just a way of changing the search scope in the
>symbol table.
>
>But then I discover that it only works for Objects not structs (or
>interfaces I assume).
>
>Walter,  please change the syntax to include the '.'; that way one can refer
>to '.x' and 'x' as two different things.
>
>And please, please make it work with anything that uses the '.' operator.
>
>A trite example:
>
>struc A {
>    int x;
>    int y;
>    func1() { return x + y; }
>}
>
>int f2(int x, int y)
>    A a;
>
>    with(a) {
>        .x = x;
>        .y = y;
>        return .func1();
>    }
>}
>
>
>
>  
>
Personally I don't see much problem with not including the dot because if you have a collision like in the case your present, its a local collision, so it's easily fixable.  Just use px, py -> and there is not much more typing involved in doing that (if typing is an issue here).

As to the structs.  Big W as said that this was an oversight, I think he'll eventually get around to fixing it.  Its on the http://www.prowiki.org/wiki4d/wiki.cgi?PendingPeeves, page.

I do a lot of code with structs and keep coming to situations where I wish I could use "with".

-- 
-Anderson: http://badmama.com.au/~anderson/

J Anderson wrote:

> Personally I don't see much problem with not including the dot because if you have a collision like in the case your present, its a local collision, so it's easily fixable.  Just use px, py -> and there is not much more typing involved in doing that (if typing is an issue here).

Of course the dot could be made optional (use it to avoid collision) but that may be to complicated.

> As to the structs.  Big W as said that this was an oversight, I think he'll eventually get around to fixing it.  Its on the http://www.prowiki.org/wiki4d/wiki.cgi?PendingPeeves, page.
>
> I do a lot of code with structs and keep coming to situations where I wish I could use "with".
>


-- 
-Anderson: http://badmama.com.au/~anderson/

Scott Egan wrote:
> Walter,  please change the syntax to include the '.'; that way one can refer
> to '.x' and 'x' as two different things.

.x already has meaning in D: is an explicit reference to the global scope.

   int x;

   class A {
      int x;
      this() {
         x = .x;
      }
   }

 -- andy

I'm not too concerned about typing so much as readability and accuracy.  It is not obvious in a with block where the variables are comming from.  I found this a bit off putting.




"J Anderson" <REMOVEanderson@badmama.com.au> wrote in message news:c70eli$gv7$1@digitaldaemon.com...
> Scott Egan wrote:
>
> >Since Walter converted his game I thought I should do mine - good reason
to
> >play with D.
> >
> >I've just tried to use the 'with' statement, and now I'm disappointed.
> >
> >Firstly I tried made the mistake of putting '.' infront of the members I
was
> >refering to (aka VB) - fail.
> >
> >OK so I learnt that its just a way of changing the search scope in the symbol table.
> >
> >But then I discover that it only works for Objects not structs (or
> >interfaces I assume).
> >
> >Walter,  please change the syntax to include the '.'; that way one can
refer
> >to '.x' and 'x' as two different things.
> >
> >And please, please make it work with anything that uses the '.' operator.
> >
> >A trite example:
> >
> >struc A {
> >    int x;
> >    int y;
> >    func1() { return x + y; }
> >}
> >
> >int f2(int x, int y)
> >    A a;
> >
> >    with(a) {
> >        .x = x;
> >        .y = y;
> >        return .func1();
> >    }
> >}
> >
> >
> >
> >
> >
> Personally I don't see much problem with not including the dot because if you have a collision like in the case your present, its a local collision, so it's easily fixable.  Just use px, py -> and there is not much more typing involved in doing that (if typing is an issue here).
>
> As to the structs.  Big W as said that this was an oversight, I think he'll eventually get around to fixing it.  Its on the http://www.prowiki.org/wiki4d/wiki.cgi?PendingPeeves, page.
>
> I do a lot of code with structs and keep coming to situations where I wish I could use "with".
>
> -- 
> -Anderson: http://badmama.com.au/~anderson/

Scott Egan wrote:

>> int f2(int x, int y)
>>    A a;
>>
>>    with(a) {
>>        .x = x;
>>        .y = y;
>>        return .func1();
>>    }
>> }

J Anderson wrote:

> Personally I don't see much problem with not including the dot because if you have a collision like in the case your present, its a local collision, so it's easily fixable.  Just use px, py -> and there is not much more typing involved in doing that (if typing is an issue here).

It annoys me to have to rename arguments to get this to work,
but it's not because I'm concerned about having more to type.
It's just that I'd like to be able to use the same variable
names across the board, and not have to rename variables or
give up the convenience (and readability) of with blocks.

For what it's worth, I'd like to echo Scott's preference for
the dots being used in the with block, for the following reasons.

1. Consistency with other languages

Delphi did with blocks this way, and so did Visual Basic and
other languages influenced by Delphi.

2. Logical consistency

I believe that:

int f(int x, int y) {
  with(a) {
    .x = x;
    .y = y;
  }
}

...should be exactly equivalent to:

int f(int x, int y) {
  a.x = x;
  a.y = y;
}

Note that no variable renaming is required.

If this conflicts with the syntax for indicating
global scope, I think it is the global scope syntax
that should be changed:
e.g. .x becomes ::x or global.x

Then I could write:

int f(int x) {
  with(a) {
    .x = ::x; // uses global x
    .x = x;   // uses local x
  }
}

James McComb

James McComb wrote:
> 1. Consistency with other languages
> 
> Delphi did with blocks this way, and so did Visual Basic and
> other languages influenced by Delphi.

And JavaScript has always worked without the .'s.  If you just base things off other languages, you have to pick which - and I would note that Delphi and Visual Basic are not as "C like" as JavaScript is.

> 
> 2. Logical consistency

Just your logic, though... maybe not everyone shares that logic.

> If this conflicts with the syntax for indicating
> global scope, I think it is the global scope syntax
> that should be changed:
> e.g. .x becomes ::x or global.x
> 

Or is bad.... makes things confusing I say.  If it means just one thing, it is more logical.  Not less.

-[Unknown]

Unknown W. Brackets wrote:

> And JavaScript has always worked without the .'s.  If you just base things off other languages, you have to pick which - and I would note that Delphi and Visual Basic are not as "C like" as JavaScript is.

Fair enough. I didn't know about JavaScript with blocks.
Forget about other languages, then.

> Just your logic, though... maybe not everyone shares that logic.

Maybe they don't, but maybe they should. ;)

Here are two other reasons why with block should have the dots.

1. Readability

In the middle of a long function you come across:

with(a) {
  x = y;
}

Without the dots, you can't tell at a glance whether
this means a.x = y or x = a.y or even just x = y!

2. Auto-complete editor support

Inside a with block, you type a dot. Lo and behold, up
pops a list of methods for the containing with block.

>> If this conflicts with the syntax for indicating
>> global scope, I think it is the global scope syntax
>> that should be changed:
>> e.g. .x becomes ::x or global.x
>>
> 
> Or is bad.... makes things confusing I say.  If it means just one thing, it is more logical.  Not less.

I am not suggesting that any construct have two meanings.
I am suggesting something like:

.x always means the scope of the with block
::x always means global scope

James McComb

James McComb wrote:

>
> 2. Auto-complete editor support
>
> Inside a with block, you type a dot. Lo and behold, up
> pops a list of methods for the containing with block.

Good point but that still doesn't show why it can't be optional.

-- 
-Anderson: http://badmama.com.au/~anderson/