building quotient from ideal to make it more explicit

examples/quotient.rs

@@ -3,19 +3,20 @@ use std::rc::Rc;
 use circuit_cas::circuit::dag::CircuitExt;
 use circuit_cas::circuit::quotient::QuotientCircuit;
 use circuit_cas::circuit::traits::Circuit;
+use circuit_cas::poly::ideal::{Generators, Ideal};
 use circuit_cas::var;
 
 fn main() {
     let x = var!("x");
     let nx = var!("x\u{0304}");
 
-    let idem = vec![
+    let idem: Ideal<_, Generators> = vec![
         1 * (&x ^ 2) - 1 * (&x ^ 1),
         1 * (&nx ^ 2) - 1 * (&nx ^ 1),
         1 * ((&x ^ 1) * (&nx ^ 1)) - 1 * (&x ^ 1),
-    ];
+    ].into();
 
-    let quotient: Rc<RefCell<QuotientCircuit>> = idem.into_iter().collect();
+    let quotient: Rc<RefCell<QuotientCircuit>> = idem.into();
 
     // Build x * x̄ + x in the DAG
     let xn   = quotient.var("x");

src/circuit/quotient.rs

@@ -3,7 +3,6 @@ use std::ops::{Deref, DerefMut};
 use std::rc::Rc;
 
 use crate::poly::var::{StaticVar, Var};
-use crate::poly::flat::Poly;
 use crate::poly::ideal::{Generators, GroebnerBasis, Ideal};
 use super::dag::{Dag, NodeId};
 use super::traits::{Node, SumProdCircuit};
@@ -34,26 +33,15 @@ pub struct QuotientCircuit<V: Var = StaticVar> {
     dag: Dag<QNode<V>>,
 }
 
-impl<V: Var> QuotientCircuit<V> {
-    pub fn from_ideal(basis: Ideal<V, GroebnerBasis>) -> Rc<RefCell<Self>> {
-        Rc::new(RefCell::new(Self { basis, dag: Default::default() }))
-    }
-
-    pub fn from_polys(iter: impl IntoIterator<Item = Poly<V>>) -> Rc<RefCell<Self>> {
-        let ideal: Ideal<V, Generators> = iter.into_iter().collect();
-        Rc::new(RefCell::new(Self { basis: ideal.groebner_basis(), dag: Default::default() }))
+impl<V: Var> From<Ideal<V, Generators>> for Rc<RefCell<QuotientCircuit<V>>> {
+    fn from(ideal: Ideal<V, Generators>) -> Self {
+        ideal.groebner_basis().into()
     }
 }
 
 impl<V: Var> From<Ideal<V, GroebnerBasis>> for Rc<RefCell<QuotientCircuit<V>>> {
     fn from(basis: Ideal<V, GroebnerBasis>) -> Self {
-        QuotientCircuit::from_ideal(basis)
-    }
-}
-
-impl<V: Var> FromIterator<Poly<V>> for Rc<RefCell<QuotientCircuit<V>>> {
-    fn from_iter<T: IntoIterator<Item = Poly<V>>>(iter: T) -> Self {
-        QuotientCircuit::from_polys(iter)
+        Rc::new(RefCell::new(QuotientCircuit { basis, dag: Default::default() }))
     }
 }