Remove duplicate exports from pub use

src/builder/bdd/builder.rs

@@ -9,10 +9,9 @@ use crate::repr::model::PartialModel;
 
 use crate::builder::BottomUpBuilder;
 
-pub use crate::builder::cache::LruTable;
-pub use crate::repr::bdd::BddPtr;
-pub use crate::repr::ddnnf::DDNNFPtr;
-pub use crate::repr::var_label::VarLabel;
+use crate::repr::bdd::BddPtr;
+use crate::repr::ddnnf::DDNNFPtr;
+use crate::repr::var_label::VarLabel;
 
 use super::CompiledCNF;
 

src/builder/bdd/mod.rs

@@ -1,6 +1,6 @@
 use std::cmp::Ordering;
 
-use self::robdd::{BddPtr, VarLabel};
+use crate::repr::{bdd::BddPtr, var_label::VarLabel};
 
 pub mod builder;
 pub mod robdd;

src/builder/bdd/robdd.rs

@@ -10,10 +10,10 @@ use crate::backing_store::*;
 use crate::builder::BottomUpBuilder;
 use std::cell::RefCell;
 
-pub use crate::builder::cache::LruTable;
-pub use crate::repr::bdd::BddPtr;
-pub use crate::repr::ddnnf::DDNNFPtr;
-pub use crate::repr::var_label::VarLabel;
+use crate::builder::cache::LruTable;
+use crate::repr::bdd::BddPtr;
+use crate::repr::ddnnf::DDNNFPtr;
+use crate::repr::var_label::VarLabel;
 
 use super::builder::BddBuilder;
 use super::stats::BddBuilderStats;

src/builder/decision_nnf/builder.rs

@@ -1,14 +1,14 @@
 use rustc_hash::FxHashMap;
 
 use crate::{
-    builder::{
-        bdd::robdd::{BddPtr, DDNNFPtr},
-        TopDownBuilder,
-    },
+    builder::TopDownBuilder,
     repr::{
-        bdd::{BddNode, Literal, VarOrder},
+        bdd::{BddNode, BddPtr},
         cnf::Cnf,
+        ddnnf::DDNNFPtr,
         unit_prop::{DecisionResult, SATSolver},
+        var_label::Literal,
+        var_order::VarOrder,
     },
 };
 

src/builder/decision_nnf/semantic.rs

@@ -8,11 +8,13 @@ use rustc_hash::FxHasher;
 
 use crate::{
     backing_store::bump_table::BackedRobinhoodTable,
-    builder::{
-        bdd::robdd::{BddPtr, DDNNFPtr},
-        decision_nnf::builder::{DecisionNNFBuilder, DecisionNNFBuilderStats},
+    builder::decision_nnf::builder::{DecisionNNFBuilder, DecisionNNFBuilderStats},
+    repr::{
+        bdd::{BddNode, BddPtr},
+        ddnnf::{create_semantic_hash_map, DDNNFPtr},
+        var_order::VarOrder,
+        wmc::WmcParams,
     },
-    repr::bdd::{create_semantic_hash_map, BddNode, VarOrder, WmcParams},
     util::semirings::finitefield::FiniteField,
 };
 
@@ -111,12 +113,11 @@ impl<'a, const P: u128> SemanticDecisionNNFBuilder<'a, P> {
 mod tests {
 
     use crate::{
-        builder::{
-            bdd::robdd::DDNNFPtr,
-            decision_nnf::{builder::DecisionNNFBuilder, semantic::SemanticDecisionNNFBuilder},
+        builder::decision_nnf::{
+            builder::DecisionNNFBuilder, semantic::SemanticDecisionNNFBuilder,
         },
         constants::primes,
-        repr::{bdd::VarOrder, cnf::Cnf},
+        repr::{cnf::Cnf, ddnnf::DDNNFPtr, var_order::VarOrder},
     };
 
     #[test]

src/builder/decision_nnf/standard.rs

@@ -2,12 +2,13 @@ use std::{cell::RefCell, collections::HashSet};
 
 use crate::{
     backing_store::bump_table::BackedRobinhoodTable,
-    builder::{
-        bdd::robdd::{BddPtr, DDNNFPtr},
-        decision_nnf::builder::{DecisionNNFBuilder, DecisionNNFBuilderStats},
-    },
+    builder::decision_nnf::builder::{DecisionNNFBuilder, DecisionNNFBuilderStats},
     constants::primes,
-    repr::bdd::{create_semantic_hash_map, BddNode, VarOrder},
+    repr::{
+        bdd::{BddNode, BddPtr},
+        ddnnf::{create_semantic_hash_map, DDNNFPtr},
+        var_order::VarOrder,
+    },
 };
 
 use crate::backing_store::UniqueTable;
@@ -71,11 +72,10 @@ impl<'a> StandardDecisionNNFBuilder<'a> {
 mod tests {
 
     use crate::{
-        builder::{
-            bdd::robdd::DDNNFPtr,
-            decision_nnf::{builder::DecisionNNFBuilder, standard::StandardDecisionNNFBuilder},
+        builder::decision_nnf::{
+            builder::DecisionNNFBuilder, standard::StandardDecisionNNFBuilder,
         },
-        repr::{bdd::VarOrder, cnf::Cnf},
+        repr::{cnf::Cnf, ddnnf::DDNNFPtr, var_order::VarOrder},
     };
 
     #[test]

src/builder/sdd/semantic.rs

@@ -6,8 +6,7 @@ use rustc_hash::FxHasher;
 
 use crate::backing_store::bump_table::BackedRobinhoodTable;
 use crate::builder::cache::ite::Ite;
-use crate::repr::bdd::create_semantic_hash_map;
-use crate::repr::ddnnf::DDNNFPtr;
+use crate::repr::ddnnf::{create_semantic_hash_map, DDNNFPtr};
 use crate::repr::sdd::binary_sdd::BinarySDD;
 use crate::repr::sdd::sdd_or::{SddAnd, SddOr};
 use crate::repr::sdd::SddPtr;
@@ -236,8 +235,6 @@ impl<'a, const P: u128> SemanticSddBuilder<'a, P> {
 fn prob_equiv_sdd_demorgan() {
     use crate::builder::BottomUpBuilder;
     use crate::constants::primes;
-    use crate::repr::bdd::create_semantic_hash_map;
-    use crate::repr::bdd::WmcParams;
     use crate::repr::var_label::VarLabel;
     use crate::util::semirings::finitefield::FiniteField;
 

src/repr/bdd.rs

@@ -1,21 +1,25 @@
 //! Binary decision diagram representation
 
-pub use super::{
-    ddnnf::*,
-    model::PartialModel,
-    var_label::{Literal, VarLabel},
-    var_order::VarOrder,
-    wmc::WmcParams,
-};
 use crate::{
-    repr::var_label::VarSet,
+    repr::ddnnf::{DDNNFPtr, DDNNF},
+    repr::model::PartialModel,
+    repr::var_label::{Literal, VarLabel, VarSet},
+    repr::var_order::VarOrder,
+    repr::wmc::WmcParams,
     util::semirings::expectation::ExpectedUtility,
     util::semirings::semiring_traits::{BBSemiring, JoinSemilattice},
     util::semirings::{finitefield::FiniteField, realsemiring::RealSemiring},
 };
 use bit_set::BitSet;
 use core::fmt::Debug;
-use std::{any::Any, cell::RefCell, iter::FromIterator, ptr};
+use std::{
+    any::Any,
+    cell::RefCell,
+    collections::HashMap,
+    hash::{Hash, Hasher},
+    iter::FromIterator,
+    ptr,
+};
 use BddPtr::*;
 
 /// Core BDD pointer datatype
@@ -174,7 +178,10 @@ impl<'a> BddPtr<'a> {
     /// convert a BddPtr into a regular (non-complemented) pointer,
     /// but does not change the underlying node.
     /// ```
-    /// use rsdd::repr::bdd::*;
+    /// use rsdd::repr::{
+    ///     bdd::{BddNode, BddPtr},
+    ///     var_label::VarLabel
+    /// };
     ///
     /// assert_eq!(BddPtr::PtrTrue, BddPtr::PtrTrue.to_reg());
     /// assert_eq!(BddPtr::PtrTrue, BddPtr::PtrFalse.to_reg());
@@ -195,7 +202,11 @@ impl<'a> BddPtr<'a> {
     }
 
     /// ```
-    /// use rsdd::repr::bdd::*;
+    /// use rsdd::repr::{
+    ///     bdd::{BddNode, BddPtr},
+    ///     var_label::VarLabel
+    /// };
+    ///
     /// // this node represents the positive literal 0
     /// let node = BddNode::new(VarLabel::new(0), BddPtr::PtrFalse, BddPtr::PtrTrue);
     ///
@@ -213,7 +224,11 @@ impl<'a> BddPtr<'a> {
     }
 
     /// ```
-    /// use rsdd::repr::bdd::*;
+    /// use rsdd::repr::{
+    ///     bdd::{BddNode, BddPtr},
+    ///     var_label::VarLabel
+    /// };
+    ///
     /// // this node represents the positive literal 0
     /// let node = BddNode::new(VarLabel::new(0), BddPtr::PtrFalse, BddPtr::PtrTrue);
     ///
@@ -231,7 +246,11 @@ impl<'a> BddPtr<'a> {
     }
 
     /// ```
-    /// use rsdd::repr::bdd::*;
+    /// use rsdd::repr::{
+    ///     bdd::{BddNode, BddPtr},
+    ///     var_label::VarLabel
+    /// };
+    ///
     /// // this node represents the positive literal 0
     /// let node = BddNode::new(VarLabel::new(0), BddPtr::PtrFalse, BddPtr::PtrTrue);
     ///
@@ -249,7 +268,11 @@ impl<'a> BddPtr<'a> {
     }
 
     /// ```
-    /// use rsdd::repr::bdd::*;
+    /// use rsdd::repr::{
+    ///     bdd::{BddNode, BddPtr},
+    ///     var_label::VarLabel
+    /// };
+    ///
     /// // this node represents the positive literal 0
     /// let node = BddNode::new(VarLabel::new(0), BddPtr::PtrFalse, BddPtr::PtrTrue);
     ///
@@ -282,7 +305,11 @@ impl<'a> BddPtr<'a> {
 
     /// true if the BddPtr points to a constant (i.e., True or False)
     /// ```
-    /// use rsdd::repr::bdd::*;
+    /// use rsdd::repr::{
+    ///     bdd::{BddNode, BddPtr},
+    ///     var_label::VarLabel
+    /// };
+    ///
     /// assert!(BddPtr::is_const(&BddPtr::PtrTrue));
     /// assert!(BddPtr::is_const(&BddPtr::PtrFalse));
     ///
@@ -1050,10 +1077,6 @@ impl<'a> PartialEq for BddNode<'a> {
     }
 }
 
-use std::{
-    collections::HashMap,
-    hash::{Hash, Hasher},
-};
 impl<'a> Hash for BddNode<'a> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.var.hash(state);

src/repr/sdd.rs

@@ -6,11 +6,14 @@ pub mod sdd_or;
 
 use crate::{
     repr::{
-        ddnnf::DDNNF,
+        ddnnf::{DDNNFPtr, DDNNF},
         var_label::{VarLabel, VarSet},
+        vtree::{VTreeIndex, VTreeManager},
+        wmc::WmcParams,
     },
     util::semirings::finitefield::FiniteField,
 };
+
 use std::fmt::Debug;
 use std::{collections::HashSet, ptr};
 use SddPtr::*;
@@ -60,12 +63,6 @@ impl<'a> PartialEq for SddPtr<'a> {
     }
 }
 
-use super::{
-    bdd::WmcParams,
-    ddnnf::DDNNFPtr,
-    vtree::{VTreeIndex, VTreeManager},
-};
-
 impl<'a> SddPtr<'a> {
     /// performs a semantic hash and caches the result on the node
     pub fn cached_semantic_hash<const P: u128>(