Struct AtomArena 

pub struct AtomArena<'a> { /* private fields */ }

A context that allocates Atoms in an Arena.

All construction methods are immutable from the caller’s perspective; mutation happens through the arena’s interior mutability. Identical sub-expressions are hash-consed so that structural equality implies pointer equality.

Example

use ocas_atom::AtomArena;
use ocas_core::arena::Arena;

let arena = Arena::new();
let ctx = AtomArena::new(&arena);
let x = ctx.var("x");
let y = ctx.var("y");
let sum = ctx.add(&[x, y]);
assert_eq!(sum.to_string(), "x + y");

Implementations

impl<'a> AtomArena<'a>

pub fn new(arena: &'a Arena) -> Self

Create an AtomArena backed by the given arena.

Example

use ocas_atom::AtomArena;
use ocas_core::arena::Arena;

let arena = Arena::new();
let ctx = AtomArena::new(&arena);
let n = ctx.num(42);
assert_eq!(n.to_string(), "42");

pub fn num(&self, value: i64) -> Atom<'a>

Create an integer literal atom.

Example

use ocas_atom::AtomArena;
use ocas_core::arena::Arena;

let arena = Arena::new();
let ctx = AtomArena::new(&arena);
let n = ctx.num(7);
assert_eq!(n.to_string(), "7");

pub fn var(&self, name: &str) -> Atom<'a>

Create a variable atom from a name.

Example

use ocas_atom::AtomArena;
use ocas_core::arena::Arena;

let arena = Arena::new();
let ctx = AtomArena::new(&arena);
let x = ctx.var("x");
assert_eq!(x.to_string(), "x");

pub fn fun(&self, name: &str, args: &[Atom<'a>]) -> Atom<'a>

Create a function application atom.

Panics

Panics in debug mode if args is empty.

Example

use ocas_atom::AtomArena;
use ocas_core::arena::Arena;

let arena = Arena::new();
let ctx = AtomArena::new(&arena);
let x = ctx.var("x");
let f = ctx.fun("sin", &[x]);
assert_eq!(f.to_string(), "sin(x)");

pub fn add(&self, args: &[Atom<'a>]) -> Atom<'a>

Create an addition atom.

Panics

Panics in debug mode if args is empty.

Example

use ocas_atom::AtomArena;
use ocas_core::arena::Arena;

let arena = Arena::new();
let ctx = AtomArena::new(&arena);
let x = ctx.var("x");
let y = ctx.var("y");
let sum = ctx.add(&[x, y]);
assert_eq!(sum.to_string(), "x + y");

pub fn mul(&self, args: &[Atom<'a>]) -> Atom<'a>

Create a multiplication atom.

Panics

Panics in debug mode if args is empty.

Example

use ocas_atom::AtomArena;
use ocas_core::arena::Arena;

let arena = Arena::new();
let ctx = AtomArena::new(&arena);
let x = ctx.var("x");
let y = ctx.var("y");
let product = ctx.mul(&[x, y]);
assert_eq!(product.to_string(), "x*y");

pub fn pow(&self, base: Atom<'a>, exp: Atom<'a>) -> Atom<'a>

Create a power atom.

Example

use ocas_atom::AtomArena;
use ocas_core::arena::Arena;

let arena = Arena::new();
let ctx = AtomArena::new(&arena);
let x = ctx.var("x");
let p = ctx.pow(x, ctx.num(3));
assert_eq!(p.to_string(), "x^3");

pub fn slice(&self, atoms: &[Atom<'a>]) -> &'a [Atom<'a>]

Allocate a slice of atoms in the arena.

Used for returning multiple results that share the arena lifetime, such as the component solutions of an ODE system.