On Monday, 13 November 2023 at 02:23:22 UTC, Imperatorn wrote:

Thank you,Have a nice day!

On Monday, 13 November 2023 at 03:07:07 UTC, Mike Parker wrote:
https://gist.github.com/mdparker/f28c9ae64f096cd06db6b987318cc581

I can't access https://gist.github.com,
Anyway, thank you for your efforts.

On Monday, 13 November 2023 at 04:47:42 UTC, matheus wrote:

Thank you, Matheus.Have a nice day.

On Sunday, 12 November 2023 at 19:50:02 UTC, Mike Parker wrote:

Thank you for posting. As always, it's interesting read. And it's great for the community to get the feeling for what's happening.

Nice to see that people such as Adam and Timon joined these discussions recently.

Topic-wise, I would be interested in how the "shared" is going to be shaped. Especially, I remember Manu advocating for a quite simple in principle approach to it, but he never got to much positive vibes from the community. I noticed his suggestions mentioned in the summary notes of the DLF meeting, and wondered whether some of those ideas will be part of the discussion.

On Sunday, 12 November 2023 at 21:55:31 UTC, Paul Backus wrote:

I have already brought that up to one of our work group meetings regarding dmd as a library as I have stumbled upon this also. We have a solution for this, I'm going to try to implement it this week.

RazvanN

On Monday, 13 November 2023 at 00:18:35 UTC, Richard (Rikki) Andrew Cattermole wrote:

Just to once again add my own view, since I don't see it represented a lot:

Remove shared or don't, at least stop making synchronized imply shared. I don't care about shared, I don't care about atomics, I want to use the mutex style of protecting access, where I manually think about who exclusively owns what memory. But I can't use synchronized, because then I have to cast every access to this, which is clearly insane, and as a result invariant-using class code is straight up incorrect, because I have literally no choice but to do this:

class Foo
{
  private int[] array;

  invariant { synchronized (this) { assert(this.array.all!(i => i > 0)); } }

  void foo(int i)
  in (i > 0)
  {
    synchronized (this)
    {
      // Note that the invariant on `array` is not actually guaranteed here!
      // Some other method in another thread might currently have set up a violation
      // for it, but switched out before its out invariant could be locked and tested.
      // So we can have a *wrong invariant in this method,* which has done absolutely
      // nothing wrong. Very fun!!
      array ~= i;
    }
  }
}

The only way to prevent this is synchronized class, but even if all missing features are implemented, array would be shared. Which is just wrong, as array is privately owned storage of the class, a fact I cannot prove to the compiler but is nonetheless true. synchronized class brings in the one feature I don't want to use and makes it an unavoidable condition of literally writing correct code at all. So yeah shared, I didn't want to be your enemy but apparently you wanted to be mine. shared delenda est.

On Monday, 13 November 2023 at 10:01:23 UTC, RazvanN wrote:

That's great to hear! Thanks for letting me know.

On Sunday, 12 November 2023 at 19:50:02 UTC, Mike Parker wrote:

Thanks for the detailed summary, I'm reading them all!

On Sunday, 12 November 2023 at 21:55:31 UTC, Paul Backus wrote:

The visitor can already be extern(D). Only member functions overriding those in the base class need to be extern(C++). Other member functions can then use paratemers, which would be incompatible with extern(C++).