Struct AtomToRust 

pub struct AtomToRust { /* private fields */ }

Converts Symbolica Atom expressions to Rust TokenStream.

This converter handles the translation of symbolic mathematical expressions into efficient Rust code, properly handling:

• Field accessors (e.g., a_x → a.x())
• Numeric constants (0, 1, 2, etc.)
• Arithmetic operations (+, -, *, powers)

Example

use clifford_codegen::symbolic::AtomToRust;

let converter = AtomToRust::new(&[&type_a, &type_b], &["a", "b"]);
let atom = Atom::parse("a_x * b_y + a_y * b_x").unwrap();
let code = converter.convert(&atom);
// Produces: a.x() * b.y() + a.y() * b.x()

Implementations

impl AtomToRust

pub fn new(types: &[&TypeSpec], prefixes: &[&str]) -> Self

Creates a new converter for the given types and prefixes.

Arguments

• types - The types whose fields will appear in expressions
• prefixes - The variable prefixes used (e.g., “a”, “b”)

Example

let converter = AtomToRust::new(&[&vector_type, &bivector_type], &["a", "b"]);

pub fn new_with_wrappers( types: &[&TypeSpec], prefixes: &[&str], wrapper_prefixes: &[&str], ) -> Self

Creates a converter with wrapper type support.

Arguments

• types - The types whose fields will appear in expressions
• prefixes - The variable prefixes used (e.g., “self”, “rhs”)
• wrapped_prefixes - Prefixes that use wrapper types (need .as_inner())

Example

// For Wedge<B> for Unit<A>: self is wrapped, rhs is not
let converter = AtomToRust::new_with_wrappers(
    &[&type_a, &type_b],
    &["self", "rhs"],
    &["self"],  // self needs .as_inner()
);

pub fn convert(&self, atom: &Atom) -> TokenStream

Converts a Symbolica Atom to a Rust TokenStream.