ergo VS gcpp

> A) is easy to write one off scripts that do a job fast, with minimal thinking and effort. I am thinking of Python and Ruby. For me I can write code with high velocity in these languages.

Once I wrap up some other projects, I plan to explore this space a little bit within Rust.

imo the biggest bang for the buck is just having good `#!` support. Probably mid-year I expect to have a Pre-RFC up for single-file cargo packages. See https://github.com/epage/cargo-script-mvs/discussions/15.

A bigger effort is a batteries included, non-zero cost stdlib. I've started writing up my thoughts at https://github.com/ergo-rs/ergo.

For more background on why I think these are important, see https://epage.github.io/blog/2021/09/learning-rust/.

Would love feedback on these ideas and other ways to make Rust easy to use without sacrificing what makes Rust it is.

static reflection and pattern-matching, as everyone is saying, but I'd also like to see a garbage-collecting smart-pointer in the standard library similar in design to Herb Sutter's deferred_ptr

There are definitely fringe edge cases where C++ can do things that Rust simply cannot, currently.

I'm thinking of things like Herb Sutter's deferred_heap (https://github.com/hsutter/gcpp) that give you GC-like abstraction. It's pretty cool that this is possible to write in vanilla C++ with decent ergonomics. I tried to make something similar awhile back and hit a wall in terms of making something that would be pleasant to use.

Rust has several on-going experiments with making a nice GC, along with good support for arenas. (If you can use arenas, they're great.)

Check out this library: https://github.com/hsutter/gcpp

Hm, yeah, that's pretty unclear. My understanding is based off the link to Herb's proposal in the OP, which I understand this to be an evolution of.

Re garbage collection: My understanding was that the standard API was intended for interop with managed languages, not for pure C++ code to use, although I could be mistaken. I don't think garbage collection is entirely a lost cause, for instance Herb Sutter's work, which I think he wants to integrate in Cppfront, would be a great way to do it. Imo, his garbage collection ([1] [2]) could be much better than D or Nim, because it has easily controllable performance characteristics. You don't pay for it if you won't use it, and it's unlikely that libraries you pull in would need it, which is imo what makes programming without the "optional" GC in D and Nim difficult.

Herb Sutter

Something like gcpp would be quite nice. That and a intelligent scope detector could make use of isolated and local GC when it detects that some objects stays together and have similar lifetime.