[ezy]

I prefer well known memory lifetimes, but I'm undecided about ARC (or somewhat equivalently: std::shared_ptr, etc.). It can be a little confusing and overwrought at times, and I don't think the lifetimes are as clear as they could be.

IMO, more languages shouldn't assume that there is a single memory allocator. That's one of the worst assumptions I see in systems languages -- even C++ (before C++11) got this entirely wrong. Swift gets this wrong, Go gets this wrong. Rust is probably a little better because it actually has a static idea of memory scope, but I haven't seen a way to swap out the memory allocator in various contexts.

Most projects I've been involved with have used region/arena allocators. Not only do you mostly avoid the non-determism of your average GC, but you avoid the hassle of fine grained reference counting (in most cases). This relies on you choosing the scopes for your regions appropriately, but there usually is a clear scope to attach things to (e.g. frames, iteration of an event loop, etc.).

[mamcx]

You are talking about a arena collector? Like this:

http://wiki.luajit.org/New-Garbage-Collector

Exist some pre-madethat can be used for a new project, for use with LLVM or luajit?

[kevinnk]

Maybe you're referring to something else, but std::allocator was in c++98

[ezy]

Yes, but (according to the spec) it was stateless -- which made it worthless for the purposes I'm describing. The original purpose was to support custom static strategies for allocation (e.g. i86 near/far pointers or one memory pool for one kind of object for the whole program), not dynamic memory pools and arenas. C++11 fixed that, which is why I mentioned it.

That said, by C++03, most STL implementations supported stateful allocators (and that's what I've used when I've had to use C++), but the standard took a while to catch up.

[Dewie]

> , but I haven't seen a way to swap out the memory allocator in various contexts.

You mean something like this?

https://github.com/rust-lang/rfcs/pull/244

I think part of it was inspired by something similar from C++. D-lang also seems to have something like this.

[ezy]

Yup. That's excellent. Rust changes so fast, I can hardly keep up. :-)

[Dewie]

Sadly though I haven't been able to find any mention of if and when it will be realized. But the sentiment - from what I've gleaned from discussions on it - seems to be that something like that should/need to happen.