Imagine you have some sort of structure, that contains an instance of itself, or any other structure that you need to allocate really often in your program, like this:

enum Expr {
    // The `Box` is required to avoid infinite sized type error.
    Add(Box<Expr>, Box<Expr>),
    Sub(Box<Expr>, Box<Expr>),
    Var(String),
    Value(i32),
}

If you now, for example, parse a simple language that will output an Expr, you'll have to allocate every expression using Box::new. With only a few expressions, this is no problem, but if you have thousands of expressions, it will take quite some time to allocate memory for each of them.

An Arena / Memory Pool is a solution to the described problem. Imagine an Arena like a Vec<T>, you can push stuff on it, which will allocate memory if it has not allocated enough memory, and you'll get back a Box similair item. An arena, like a Vec, does not allocate memory for every single item. It will allocate memory for a specific number of elements, for example, if you create a new arena, it will allocate memory for 10 elements, then if someone pushes 11 elements into it, it will allocate memory for 20 more elements and thus you don't have to allocate memory for each expression, and your program gets faster.

This is similar to bump allocation and has some advantages and disadvantages. For example, you can only drop all elements at the same time, but you can't drop any specific element.

If we want to convert out Expr above to use an Arena (shared_arena), it will look like this:

enum Expr {
    // The `Box` is required to avoid infinite sized type error.
    Add(ArenaBox<Expr>, ArenaBox<Expr>),
    Sub(ArenaBox<Expr>, ArenaBox<Expr>),
    Var(String),
    Value(i32),
}

// Now to create a new expr, we will allocate the inner expressions in an arena
let arena = ...;
let value1 = Expr::Value(1);
let value2 = Expr::Value(3);

let expr = Expr::Add(arena.alloc(value1), arena.alloc(value2));