Add a builder for replacements

- The builder can perform replacements or create an iterator
- Rename replace_all to replace
- Rename replace to replace_iter in Python API

Author: benruijl

examples/fibonacci.rs

@@ -1,6 +1,6 @@
 use symbolica::{
     atom::{Atom, AtomCore},
-    id::{Match, WildcardRestriction},
+    id::Match,
     parse, symbol,
 };
 
@@ -13,8 +13,7 @@ fn main() {
     let rhs_one = Atom::new_num(1).to_pattern();
 
     // prepare the pattern restriction `x_ > 1`
-    let restrictions =
-        symbol!("x_").restrict(WildcardRestriction::filter(|v: &Match| v.to_atom() > 1));
+    let restrictions = symbol!("x_").filter(|v: &Match| v.to_atom() > 1);
 
     let mut target = parse!("f(10)").unwrap();
 
@@ -25,10 +24,14 @@ fn main() {
 
     for _ in 0..9 {
         let out = target
-            .replace_all(&pattern, &rhs, Some(&restrictions), None)
+            .replace(&pattern)
+            .when(&restrictions)
+            .with(&rhs)
             .expand()
-            .replace_all(&lhs_zero_pat, &rhs_one, None, None)
-            .replace_all(&lhs_one_pat, &rhs_one, None, None);
+            .replace(&lhs_zero_pat)
+            .with(&rhs_one)
+            .replace(&lhs_one_pat)
+            .with(&rhs_one);
 
         println!("\t{}", out);
 

examples/partition.rs

@@ -4,19 +4,16 @@ fn main() {
     let input = parse!("f(1,3,2,3,1)").unwrap();
     let (f, g) = symbol!("f", "g");
 
-    let o = input.replace_all(
-        &parse!("f(x__)").unwrap().to_pattern(),
-        &Pattern::Transformer(Box::new((
+    let o = input
+        .replace(parse!("f(x__)").unwrap())
+        .with(Pattern::Transformer(Box::new((
             Some(parse!("x__").unwrap().to_pattern()),
             vec![Transformer::Partition(
                 vec![(f, 2), (g, 2), (f, 1)],
                 false,
                 false,
             )],
-        ))),
-        None,
-        None,
-    );
+        ))));
 
     println!("> {}", o);
 }

examples/replace_all.rs

@@ -2,9 +2,9 @@ use symbolica::{atom::AtomCore, parse};
 
 fn main() {
     let expr = parse!(" f(1,2,x) + f(1,2,3)").unwrap();
-    let pat = parse!("f(1,2,y_)").unwrap().to_pattern();
-    let rhs = parse!("f(1,2,y_+1)").unwrap().to_pattern();
+    let pat = parse!("f(1,2,y_)").unwrap();
+    let rhs = parse!("f(1,2,y_+1)").unwrap();
 
-    let out = expr.replace_all(pat, rhs, None, None);
+    let out = expr.replace(pat).with(rhs);
     println!("{}", out);
 }

examples/replace_once.rs

@@ -16,7 +16,8 @@ fn main() {
         expr.as_view()
     );
 
-    for x in expr.replace_iter(&pattern, &rhs, None, None) {
+    for x in expr.replace(pattern).iter(rhs) {
+        // _iter(&pattern, &rhs, None, None) {
         println!("\t{}", x);
     }
 }

examples/streaming.rs

@@ -1,7 +1,6 @@
 use brotli::CompressorWriter;
 use symbolica::{
     atom::AtomCore,
-    id::Pattern,
     parse,
     streaming::{TermStreamer, TermStreamerConfig},
 };
@@ -19,7 +18,7 @@ fn main() {
     stream.push(input);
 
     // map every term in the expression
-    stream = stream.map(|x| x.replace_all(&pattern, &rhs, None, None).expand());
+    stream = stream.map(|x| x.replace(&pattern).with(&rhs).expand());
 
     let res = stream.to_expression();
     println!("\t+ {}", res);