Create BorrowedAtom base type

- BorrowedAtom is a Deref target for Atom - Implement all borrowed functions on BorrowedAtom - Deprecate AtomCore
benruijl · Dec 14, 2024 · e9c504b · e9c504b
1 parent 5e9279b
commit e9c504b
Show file tree

Hide file tree

Showing 54 changed files with 449 additions and 327 deletions.
diff --git a/examples/coefficient_ring.rs b/examples/coefficient_ring.rs
@@ -1,9 +1,6 @@
 use std::sync::Arc;
 
-use symbolica::{
-    atom::{Atom, AtomCore},
-    state::State,
-};
+use symbolica::{atom::Atom, state::State};
 
 fn main() {
     let expr = Atom::parse("x*z+x*(y+2)^-1*(y+z+1)").unwrap();

diff --git a/examples/collect.rs b/examples/collect.rs
@@ -1,5 +1,5 @@
 use symbolica::{
-    atom::{Atom, AtomCore},
+    atom::Atom,
     fun,
     state::State,
 };

diff --git a/examples/derivative.rs b/examples/derivative.rs
@@ -1,7 +1,4 @@
-use symbolica::{
-    atom::{Atom, AtomCore},
-    state::State,
-};
+use symbolica::{atom::Atom, state::State};
 
 fn main() {
     let x = State::get_symbol("x");

diff --git a/examples/evaluate.rs b/examples/evaluate.rs
@@ -1,5 +1,4 @@
 use ahash::HashMap;
-use symbolica::atom::AtomCore;
 use symbolica::evaluate::EvaluationFn;
 use symbolica::{atom::Atom, state::State};
 

diff --git a/examples/expansion.rs b/examples/expansion.rs
@@ -1,4 +1,4 @@
-use symbolica::atom::{Atom, AtomCore};
+use symbolica::atom::Atom;
 
 fn main() {
     let input = Atom::parse("(1+x)^3").unwrap();

diff --git a/examples/factorization.rs b/examples/factorization.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use symbolica::{
-    atom::{Atom, AtomCore},
+    atom::Atom,
     domains::{finite_field::Zp, integer::Z},
     poly::{factor::Factorize, polynomial::MultivariatePolynomial, Variable},
     state::State,

diff --git a/examples/fibonacci.rs b/examples/fibonacci.rs
@@ -1,5 +1,5 @@
 use symbolica::{
-    atom::{Atom, AtomCore, AtomView},
+    atom::{Atom, AtomView},
     id::{Match, Pattern, WildcardRestriction},
     state::{RecycledAtom, State},
 };
@@ -35,7 +35,7 @@ fn main() {
         target.replace_all_into(&pattern, &rhs, Some(&restrictions), None, &mut out);
 
         let mut out2 = RecycledAtom::new();
-        out.expand_into(None, &mut out2);
+        out.expand_into::<Atom>(None, &mut out2);
 
         out2.replace_all_into(&lhs_zero_pat, &rhs_one, None, None, &mut out);
 

diff --git a/examples/groebner_basis.rs b/examples/groebner_basis.rs
@@ -1,5 +1,5 @@
 use symbolica::{
-    atom::{Atom, AtomCore},
+    atom::Atom,
     domains::finite_field::Zp,
     poly::{groebner::GroebnerBasis, polynomial::MultivariatePolynomial, GrevLexOrder},
     state::State,

diff --git a/examples/nested_evaluation.rs b/examples/nested_evaluation.rs
@@ -1,5 +1,5 @@
 use symbolica::{
-    atom::{Atom, AtomCore},
+    atom::{representation::BorrowedAtom, Atom},
     domains::rational::Rational,
     evaluate::{CompileOptions, FunctionMap, InlineASM, OptimizationSettings},
     state::State,
@@ -64,7 +64,7 @@ fn main() {
 
     let params = vec![Atom::parse("x").unwrap()];
 
-    let evaluator = Atom::evaluator_multiple(
+    let evaluator = BorrowedAtom::evaluator_multiple(
         &[e1.as_view(), e2.as_view()],
         &fn_map,
         &params,

diff --git a/examples/optimize.rs b/examples/optimize.rs
@@ -1,5 +1,5 @@
 use symbolica::{
-    atom::{Atom, AtomCore},
+    atom::Atom,
     domains::rational::Q,
     poly::evaluate::{BorrowedHornerScheme, InstructionSetPrinter},
 };

diff --git a/examples/optimize_multiple.rs b/examples/optimize_multiple.rs
@@ -1,5 +1,5 @@
 use symbolica::{
-    atom::{Atom, AtomCore},
+    atom::Atom,
     domains::rational::Q,
     poly::evaluate::{HornerScheme, InstructionSetPrinter},
 };

diff --git a/examples/partition.rs b/examples/partition.rs
@@ -1,5 +1,5 @@
 use symbolica::{
-    atom::{Atom, AtomCore},
+    atom::Atom,
     id::Pattern,
     state::State,
     transformer::Transformer,

diff --git a/examples/pattern_match.rs b/examples/pattern_match.rs
@@ -1,5 +1,5 @@
 use symbolica::{
-    atom::{Atom, AtomCore},
+    atom::Atom,
     id::Match,
     state::State,
 };

diff --git a/examples/pattern_restrictions.rs b/examples/pattern_restrictions.rs
@@ -1,5 +1,5 @@
 use symbolica::{
-    atom::{Atom, AtomCore, AtomView},
+    atom::{Atom, AtomView},
     coefficient::CoefficientView,
     domains::finite_field,
     id::{Condition, Match, MatchSettings, WildcardRestriction},

diff --git a/examples/polynomial_gcd.rs b/examples/polynomial_gcd.rs
@@ -1,5 +1,5 @@
 use symbolica::{
-    atom::{Atom, AtomCore},
+    atom::Atom,
     domains::{integer::Z, rational::Q},
 };
 use tracing_subscriber::{fmt, prelude::*, util::SubscriberInitExt, EnvFilter};

diff --git a/examples/rational_polynomial.rs b/examples/rational_polynomial.rs
@@ -1,5 +1,5 @@
 use symbolica::{
-    atom::{Atom, AtomCore},
+    atom::Atom,
     domains::{integer::Z, rational_polynomial::RationalPolynomial},
 };
 

diff --git a/examples/replace_all.rs b/examples/replace_all.rs
@@ -1,5 +1,5 @@
 use symbolica::{
-    atom::{Atom, AtomCore},
+    atom::Atom,
     id::Pattern,
 };
 

diff --git a/examples/replace_once.rs b/examples/replace_once.rs
@@ -1,4 +1,4 @@
-use symbolica::atom::{Atom, AtomCore};
+use symbolica::atom::Atom;
 
 fn main() {
     let expr = Atom::parse("f(z)*f(f(x))*f(y)").unwrap();

diff --git a/examples/series.rs b/examples/series.rs
@@ -1,7 +1,4 @@
-use symbolica::{
-    atom::{Atom, AtomCore},
-    state::State,
-};
+use symbolica::{atom::Atom, state::State};
 
 fn main() {
     let x = State::get_symbol("x");

diff --git a/examples/solve_linear_system.rs b/examples/solve_linear_system.rs
@@ -1,7 +1,10 @@
 use std::sync::Arc;
 
 use symbolica::{
-    atom::{representation::InlineVar, Atom, AtomCore, AtomView},
+    atom::{
+        representation::{BorrowedAtom, InlineVar},
+        Atom,
+    },
     domains::{
         integer::Z,
         rational::Q,
@@ -20,7 +23,7 @@ fn solve() {
 
     let system: Vec<_> = eqs.iter().map(|e| Atom::parse(e).unwrap()).collect();
 
-    let sol = AtomView::solve_linear_system::<u8, _, InlineVar>(&system, &[x, y, z]).unwrap();
+    let sol = BorrowedAtom::solve_linear_system::<u8, _, InlineVar>(&system, &[x, y, z]).unwrap();
 
     for (v, s) in ["x", "y", "z"].iter().zip(&sol) {
         println!("{} = {}", v, s);

diff --git a/examples/streaming.rs b/examples/streaming.rs
@@ -1,6 +1,6 @@
 use brotli::CompressorWriter;
 use symbolica::{
-    atom::{Atom, AtomCore},
+    atom::Atom,
     id::Pattern,
     streaming::{TermStreamer, TermStreamerConfig},
 };

diff --git a/examples/tree_replace.rs b/examples/tree_replace.rs
@@ -1,5 +1,5 @@
 use symbolica::{
-    atom::{Atom, AtomCore},
+    atom::Atom,
     id::Match,
     state::State,
     symb,

diff --git a/src/api/python.rs b/src/api/python.rs
@@ -32,7 +32,7 @@ use smartstring::{LazyCompact, SmartString};
 use pyo3::pymodule;
 
 use crate::{
-    atom::{Atom, AtomCore, AtomType, AtomView, ListIterator, Symbol},
+    atom::{Atom, AtomType, AtomView, BorrowedAtom, ListIterator, Symbol},
     coefficient::CoefficientView,
     domains::{
         algebraic_number::AlgebraicExtension,
@@ -2978,7 +2978,7 @@ impl PythonExpression {
     /// Add this expression to `other`, returning the result.
     pub fn __add__(&self, rhs: ConvertibleToExpression) -> PyResult<PythonExpression> {
         let rhs = rhs.to_expression();
-        Ok((self.expr.as_ref() + rhs.expr.as_ref()).into())
+        Ok((self.expr.as_ref() + rhs.expr).into())
     }
 
     /// Add this expression to `other`, returning the result.
@@ -3000,7 +3000,7 @@ impl PythonExpression {
     /// Add this expression to `other`, returning the result.
     pub fn __mul__(&self, rhs: ConvertibleToExpression) -> PyResult<PythonExpression> {
         let rhs = rhs.to_expression();
-        Ok((self.expr.as_ref() * rhs.expr.as_ref()).into())
+        Ok((&self.expr * rhs.expr).into())
     }
 
     /// Add this expression to `other`, returning the result.
@@ -3011,7 +3011,7 @@ impl PythonExpression {
     /// Divide this expression by `other`, returning the result.
     pub fn __truediv__(&self, rhs: ConvertibleToExpression) -> PyResult<PythonExpression> {
         let rhs = rhs.to_expression();
-        Ok((self.expr.as_ref() / rhs.expr.as_ref()).into())
+        Ok((&self.expr / rhs.expr).into())
     }
 
     /// Divide `other` by this expression, returning the result.
@@ -3062,7 +3062,7 @@ impl PythonExpression {
 
     /// Negate the current expression, returning the result.
     pub fn __neg__(&self) -> PyResult<PythonExpression> {
-        Ok((-self.expr.as_ref()).into())
+        Ok((-self.expr.clone()).into())
     }
 
     /// Return the length of the atom.
@@ -4511,7 +4511,7 @@ impl PythonExpression {
                 ReplaceIterator::new(
                     lhs,
                     target.as_view(),
-                    crate::id::BorrowPatternOrMap::borrow(rhs),
+                    crate::id::BorrowPatternOrMap::borrow_pat_map(rhs),
                     Some(res),
                     Some(settings),
                 )
@@ -5203,9 +5203,10 @@ impl PythonExpression {
 
         let exprs = exprs.iter().map(|x| x.expr.as_view()).collect::<Vec<_>>();
 
-        let eval = Atom::evaluator_multiple(&exprs, &fn_map, &params, settings).map_err(|e| {
-            exceptions::PyValueError::new_err(format!("Could not create evaluator: {}", e))
-        })?;
+        let eval =
+            BorrowedAtom::evaluator_multiple(&exprs, &fn_map, &params, settings).map_err(|e| {
+                exceptions::PyValueError::new_err(format!("Could not create evaluator: {}", e))
+            })?;
 
         let eval_f64 = eval.map_coeff(&|x| x.to_f64());
 

diff --git a/src/atom.rs b/src/atom.rs
@@ -2,8 +2,6 @@ mod coefficient;
 mod core;
 pub mod representation;
 
-use representation::InlineVar;
-
 use crate::{
     coefficient::Coefficient,
     parser::Token,
@@ -13,12 +11,11 @@ use crate::{
 };
 use std::{cmp::Ordering, hash::Hash, ops::DerefMut, str::FromStr};
 
-pub use self::core::AtomCore;
+use self::representation::RawAtom;
 pub use self::representation::{
-    Add, AddView, Fun, KeyLookup, ListIterator, ListSlice, Mul, MulView, Num, NumView, Pow,
-    PowView, Var, VarView,
+    Add, AddView, BorrowedAtom, Fun, FunView, InlineNum, InlineVar, KeyLookup, ListIterator,
+    ListSlice, Mul, MulView, Num, NumView, Pow, PowView, Var, VarView,
 };
-use self::representation::{FunView, RawAtom};
 
 /// A symbol, for example the name of a variable or the name of a function,
 /// together with its properties.
@@ -816,7 +813,7 @@ impl Atom {
 /// For example:
 /// ```
 /// # use symbolica::{
-/// #     atom::{Atom, AtomCore, FunctionBuilder},
+/// #     atom::{Atom,, FunctionBuilder},
 /// #     state::{FunctionAttribute, State},
 /// # };
 /// # fn main() {
@@ -844,19 +841,19 @@ impl FunctionBuilder {
     }
 
     /// Add an argument to the function.
-    pub fn add_arg<T: AtomCore>(mut self, arg: T) -> FunctionBuilder {
+    pub fn add_arg<T: AsRef<BorrowedAtom>>(mut self, arg: T) -> FunctionBuilder {
         if let Atom::Fun(f) = self.handle.deref_mut() {
-            f.add_arg(arg.as_atom_view());
+            f.add_arg(arg.as_ref().to_view());
         }
 
         self
     }
 
     /// Add multiple arguments to the function.
-    pub fn add_args<T: AtomCore>(mut self, args: &[T]) -> FunctionBuilder {
+    pub fn add_args<T: AsRef<BorrowedAtom>>(mut self, args: &[T]) -> FunctionBuilder {
         if let Atom::Fun(f) = self.handle.deref_mut() {
             for a in args {
-                f.add_arg(a.as_atom_view());
+                f.add_arg(a.as_ref().to_view());
             }
         }
 
@@ -982,22 +979,23 @@ impl Atom {
     }
 
     /// Take the `self` to the power `exp`. Use [`Atom::npow()`] for a numerical power and [`Atom::rpow()`] for the reverse operation.
-    pub fn pow<T: AtomCore>(&self, exp: T) -> Atom {
+    pub fn pow<T: AsRef<BorrowedAtom>>(&self, exp: T) -> Atom {
         Workspace::get_local().with(|ws| {
             let mut t = ws.new_atom();
             self.as_view()
-                .pow_no_norm(ws, exp.as_atom_view())
+                .pow_no_norm(ws, exp.as_ref().to_view())
                 .as_view()
                 .normalize(ws, &mut t);
             t.into_inner()
         })
     }
 
     /// Take `base` to the power `self`.
-    pub fn rpow<T: AtomCore>(&self, base: T) -> Atom {
+    pub fn rpow<T: AsRef<BorrowedAtom>>(&self, base: T) -> Atom {
         Workspace::get_local().with(|ws| {
             let mut t = ws.new_atom();
-            base.as_atom_view()
+            base.as_ref()
+                .to_view()
                 .pow_no_norm(ws, self.as_view())
                 .as_view()
                 .normalize(ws, &mut t);
@@ -1006,13 +1004,13 @@ impl Atom {
     }
 
     /// Add the atoms in `args`.
-    pub fn add_many<'a, T: AtomCore + Copy>(args: &[T]) -> Atom {
+    pub fn add_many<'a, T: AsRef<BorrowedAtom> + Copy>(args: &[T]) -> Atom {
         let mut out = Atom::new();
         Workspace::get_local().with(|ws| {
             let mut t = ws.new_atom();
             let add = t.to_add();
             for a in args {
-                add.extend(a.as_atom_view());
+                add.extend(a.as_ref().to_view());
             }
 
             t.as_view().normalize(ws, &mut out);
@@ -1021,13 +1019,13 @@ impl Atom {
     }
 
     /// Multiply the atoms in `args`.
-    pub fn mul_many<'a, T: AtomCore + Copy>(args: &[T]) -> Atom {
+    pub fn mul_many<'a, T: AsRef<BorrowedAtom> + Copy>(args: &[T]) -> Atom {
         let mut out = Atom::new();
         Workspace::get_local().with(|ws| {
             let mut t = ws.new_atom();
             let add = t.to_mul();
             for a in args {
-                add.extend(a.as_atom_view());
+                add.extend(a.as_ref().to_view());
             }
 
             t.as_view().normalize(ws, &mut out);
@@ -1538,11 +1536,7 @@ impl AsRef<Atom> for Atom {
 
 #[cfg(test)]
 mod test {
-    use crate::{
-        atom::{Atom, AtomCore},
-        fun,
-        state::State,
-    };
+    use crate::{atom::Atom, fun, state::State};
 
     #[test]
     fn debug() {