On Friday, 12 November 2021 at 12:52:28 UTC, kdevel wrote:

parens can be removed that simply:

import std.stdio;
struct L
{
  struct R
  {
      static opUnary(string s : "-")() {writeln("oops");}
  }
}

void main()
{
    with (L) - R;
}

now remove the parens... oops the parser sees a binary minus ;)

On Friday, 12 November 2021 at 15:33:38 UTC, Steven Schveighoffer wrote:

I see, thanks.

Can’t say I am a fan of this proposal. Are you in the same scope as a few hundred lines above? With braces and indentation, the answer is clear. Without them, you’ll have to look for with labels that don’t stand out visually at all.

On Saturday, 13 November 2021 at 10:43:04 UTC, Ogi wrote:

No you just look for the last open brace?
The with statement doesn't behave like a stand alone scope.

On 11/13/21 5:43 AM, Ogi wrote:

I don't really understand the question. What is the confusion you are having?

Consider the scope(exit) rewrite:

{
   someCode;
   scope(exit) close(foo);
   someCode;
}

This is equivalent to:

{
   someCode;
   try { // new scope!
      someCode;
   } finally {
      close(foo);
   }
}

This introduces a new scope the same as a with: would introduce a new scope (and actually is simpler). Have you had confusion about that feature before? It makes perfect sense to me.

-Steve

On Saturday, 13 November 2021 at 14:42:55 UTC, Steven Schveighoffer wrote:

Braces and indentations keep things sane:

struct S { int x; }
S s;
with (s) {
	/*
	lots of code here
	*/
	x = 42; //is this s.x? The answer is always yes.
}

Now with with::

struct S { int x; }
S s;
with (s):
/*
lots of code here
*/
x = 42; //is this s.x? Depends on the code above.

“Lots of code” can contain anything, including something like this:

struct X {
    void x(int i) {}
}
with (X()):

In this case x isn’t even a variable, it’s a function! But it would still compile.

On Sunday, 14 November 2021 at 15:45:13 UTC, Ogi wrote:

[...]

struct S { int x; }
S s;
with (s) {
	/*
	lots of code here
	*/
	x = 42; //is this s.x? The answer is always yes.
}

Wrong: replace /* lots of code here */ with int x:

$ cat xxx.d
struct S { int x; }
void main ()
{
   S s;
   with (s) {
      int x;
      x = 42; //is this s.x? The answer is always yes.
   }
   import std.stdio;
   writeln (s);
}

$ dmd xxx
$ ./xxx
S(0)

On Sunday, 14 November 2021 at 16:51:01 UTC, kdevel wrote:

Hmm, it works indeed. Not sure if that’s intended, since the other way around is prohibited:

struct S { int x; }
void main ()
{
   S s;
   int x;
   with (s) {
      x = 42; //Error: with symbol `onlineapp.S.x` is shadowing local symbol `onlineapp.main.x`
   }
}