This is based on circle, which looks very Rust-like, and is probably the most sound design of all the contenders for the next C++. It has an actual safe-only mode, with strict aliasing, no uninit memory, and loans tracked via control-flow graph.

Many other "safe" C++ extensions just add basic bounds checking, and end at "we have smart pointers, what else do you want!?!??!?"

But I understand that if this proposal makes the cut, other compilers would implement it too and make this universal. Seeing this seems to implement all of Rust’s safety features, this would seem like a win here.

It is, although "nobody's going to rewrite millions lines of code" applies to C++ too, not only Rust.

You won't be able to just slap `#pragma safe` on top of every file and have the problem solved. It does require use of different design patterns and structuring data in a way that works with borrowing.

This looks really interesting! It does look very rust like.

    auto get_x/(a, b)(const int^/a x, const int^/b y) -> const int^/a {
      return x;
    }

I like the new `choice` type. It looks like a c++ flavored rust enum.

    template<class T+, class E+>
    choice expected {
      [[safety::unwrap]] ok(T),
      err(E);
    
      T unwrap(self) noexcept safe {
        return match(self) -> T {
          .ok(t)  => rel t;
          .err(e) => panic("{} is err".format(expected~string));
        };
      }
    };

And it only took 40 years (and the development of Java, JavaScript, Go, Rust, even smart pointers in C++ itself, etc.) for C++ implementors to realize it is a good idea!

Perhaps LLVM supporting improved memory safety (e.g. for Swift) is helpful as well.

Add rust JIT to C++. No hope to keep up with all that is going to be and has been added to C++ in last decade

What are the chances of this proposal making the cut?