https://github.com/thomcc/rust-typed-arena

The arena, a fast but limited type of allocator
https://github.com/thomcc/rust-typed-arena

Last synced: 12 days ago
JSON representation

The arena, a fast but limited type of allocator

• Host: GitHub
• URL: https://github.com/thomcc/rust-typed-arena
• Owner: thomcc
• License: mit
• Created: 2015-04-10T16:28:22.000Z (over 9 years ago)
• Default Branch: master
• Last Pushed: 2024-08-16T05:41:48.000Z (3 months ago)
• Last Synced: 2024-10-29T12:13:17.696Z (15 days ago)
• Language: Rust
• Size: 76.2 KB
• Stars: 520
• Watchers: 15
• Forks: 52
• Open Issues: 4
• Metadata Files:
  • Readme: README.md
  • Changelog: CHANGELOG.md
  • License: LICENSE

Awesome Lists containing this project

• awesome-rust-list - typed-arena - typed-arena?style=social"/> : A fast (but limited) allocation arena for values of a single type. (Memory Allocator)
• awesome-rust-list - typed-arena - typed-arena?style=social"/> : A fast (but limited) allocation arena for values of a single type. (Memory Allocator)

README

        
# `typed-arena`

[![](https://docs.rs/typed-arena/badge.svg)](https://docs.rs/typed-arena)

[![](https://img.shields.io/crates/v/typed-arena.svg)](https://crates.io/crates/typed-arena)

[![](https://img.shields.io/crates/d/typed-arena.svg)](https://crates.io/crates/typed-arena)

[![GitHub Actions Build Status](https://github.com/thomcc/rust-typed-arena/workflows/CI/badge.svg)](https://github.com/thomcc/rust-typed-arena/actions)

**A fast (but limited) allocation arena for values of a single type.**

Allocated objects are destroyed all at once, when the arena itself is destroyed.

There is no deallocation of individual objects while the arena itself is still

alive. The flipside is that allocation is fast: typically just a vector push.

There is also a method `into_vec()` to recover ownership of allocated objects

when the arena is no longer required, instead of destroying everything.

## Example

```rust

use typed_arena::Arena;

struct Monster {

    level: u32,

}

let monsters = Arena::new();

let goku = monsters.alloc(Monster { level: 9001 });

assert!(goku.level > 9000);

```

## Safe Cycles

All allocated objects get the same lifetime, so you can safely create cycles

between them. This can be useful for certain data structures, such as graphs and

trees with parent pointers.

```rust

use std::cell::Cell;

use typed_arena::Arena;

struct CycleParticipant<'a> {

    other: Cell>>,

}

let arena = Arena::new();

let a = arena.alloc(CycleParticipant { other: Cell::new(None) });

let b = arena.alloc(CycleParticipant { other: Cell::new(None) });

a.other.set(Some(b));

b.other.set(Some(a));

```

## Alternatives

### Need to allocate many different types of values?

Use multiple arenas if you have only a couple different types or try

[`bumpalo`](https://crates.io/crates/bumpalo), which is a bump-allocation arena

that can allocate heterogenous types of values.

### Want allocation to return identifiers instead of references and dealing with references and lifetimes everywhere?

Check out [`id-arena`](https://crates.io/crates/id-arena) or

[`generational-arena`](https://crates.io/crates/generational-arena).

### Need to deallocate individual objects at a time?

Check out [`generational-arena`](https://crates.io/crates/generational-arena)

for an arena-style crate or look for a more traditional allocator.