Keyboard shortcuts

Press or to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help



Thread Safety Guarantees

Topic: architecture.thread-safety

Immutable expressions enable thread-safe sharing and parallel processing without locks. Covers concurrency patterns and safety guarantees in MathHook.

Thread Safety Guarantees

This chapter covers internal implementation details of thread safety.

Immutability

All expressions are immutable after creation. This provides:

  • Thread-safe sharing: No data races
  • Lock-free operations: No synchronization overhead
  • Predictable behavior: No surprising mutations

Parallel Processing

Immutability enables efficient parallel processing:

#![allow(unused)]
fn main() {
extern crate mathhook_book;
use mathhook_book::mathhook;
use mathhook::prelude::*;
let expressions = vec![/* many expressions */];
let simplified = parallel_bulk_simplify(&expressions);
}

Concurrency Patterns

MathHook supports common concurrency patterns:

  • Data parallelism: Process multiple expressions in parallel
  • Pipeline parallelism: Chain operations across threads
  • Work stealing: Dynamic load balancing

Safety Guarantees

Rust's type system enforces:

  • No data races: Guaranteed at compile time
  • No iterator invalidation: Immutable collections
  • No use-after-free: Ownership system prevents

Examples

API Reference

  • Rust: mathhook_core::Expression
  • Python: ``
  • JavaScript: ``

See Also