What about temporary allocators ?

[serge-hulne]

Exemple from C3

fn void work()
{
    @pool()
    {
        void* buffer = tmalloc(1024);

        // use buffer here

    }; // all temporary memory from the pool is freed here
}

[nalgeon]

So uses arenas, and passes the allocator as a parameter instead of using @pool with tmalloc. It's the same bump-allocate-and-drop-it-all pattern as in C3, but more obvious:

var buf [4096]byte
arena := mem.NewArena(buf[:])

for _, item := range items {
    process(&arena, item)  // allocates without individual .Free calls
    arena.Reset()          // reclaims everything at once
}

Reset is a regular method call, not a @pool scope exit.

Unlike C3, you can choose where the underlying buffer is allocated — either on the stack (like in the example above) or on the heap:

buf := mem.AllocSlice[byte](mem.System, 4096, 4096)
defer mem.FreeSlice(mem.System, buf)
arena := mem.NewArena(buf)

The downside is that you have to pass *mem.Arena through the call chain, while C3 gets it automatically. It matches Solod's explicit way of managing memory.

[serge-hulne]

Another difference is that an arena (free(a)) tells you when the allocation ends, whereas @pool {} tells you where the memory allocation ends.

[serge-hulne]

Another constraint with an arena conceived like this, is that one needs to know the size of the arena in advance.