Tidy names, correct doctest, update CI

Author: frankmcsherry

.github/workflows/test.yml

@@ -25,6 +25,8 @@ jobs:
           toolchain: ${{ matrix.toolchain }}
       - name: Cargo test
         run: cargo test --workspace --all-targets
+      - name: Cargo doc test
+        run: cargo test --doc
 
   # Check formatting with rustfmt
   mdbook:

differential-dataflow/examples/iterate_container.rs

@@ -8,7 +8,7 @@ use timely::dataflow::operators::generic::builder_rc::OperatorBuilder;
 use differential_dataflow::{AsCollection, Collection};
 use differential_dataflow::input::Input;
 use differential_dataflow::operators::iterate::Variable;
-use differential_dataflow::collection::traits::{Enter, Leave, Negate, ResultsIn};
+use differential_dataflow::collection::containers::{Enter, Leave, Negate, ResultsIn};
 
 /// A wrapper around a container that implements the necessary traits to be used in iterative scopes.
 #[derive(Clone, Default)]

differential-dataflow/src/collection.rs

@@ -204,7 +204,7 @@ impl<G: Scope, D, R, C: Container> Collection<G, D, R, C> {
     ///         .assert_eq(&evens);
     /// });
     /// ```
-    pub fn negate(&self) -> Collection<G, D, R, C> where C: traits::Negate {
+    pub fn negate(&self) -> Collection<G, D, R, C> where C: containers::Negate {
         use timely::dataflow::channels::pact::Pipeline;
         self.inner
             .unary(Pipeline, "Negate", move |_,_| move |input, output| {
@@ -233,9 +233,9 @@ impl<G: Scope, D, R, C: Container> Collection<G, D, R, C> {
     ///     data.assert_eq(&result);
     /// });
     /// ```
-    pub fn enter<'a, T>(&self, child: &Child<'a, G, T>) -> Collection<Child<'a, G, T>, D, R, <C as traits::Enter<<G as ScopeParent>::Timestamp, T>>::InnerContainer>
+    pub fn enter<'a, T>(&self, child: &Child<'a, G, T>) -> Collection<Child<'a, G, T>, D, R, <C as containers::Enter<<G as ScopeParent>::Timestamp, T>>::InnerContainer>
     where
-        C: traits::Enter<<G as ScopeParent>::Timestamp, T, InnerContainer: Container>,
+        C: containers::Enter<<G as ScopeParent>::Timestamp, T, InnerContainer: Container>,
         T: Refines<<G as ScopeParent>::Timestamp>,
     {
         use timely::dataflow::channels::pact::Pipeline;
@@ -258,7 +258,6 @@ impl<G: Scope, D, R, C: Container> Collection<G, D, R, C> {
     /// use timely::dataflow::operators::{ToStream, Concat, Inspect, BranchWhen};
     ///
     /// use differential_dataflow::input::Input;
-    /// use differential_dataflow::operators::ResultsIn;
     ///
     /// timely::example(|scope| {
     ///     let summary1 = 5;
@@ -270,7 +269,7 @@ impl<G: Scope, D, R, C: Container> Collection<G, D, R, C> {
     /// ```
     pub fn results_in(&self, step: <G::Timestamp as Timestamp>::Summary) -> Self
     where
-        C: traits::ResultsIn<<G::Timestamp as Timestamp>::Summary>,
+        C: containers::ResultsIn<<G::Timestamp as Timestamp>::Summary>,
     {
         use timely::dataflow::channels::pact::Pipeline;
         self.inner
@@ -597,7 +596,7 @@ use timely::progress::timestamp::Refines;
 /// Methods requiring a nested scope.
 impl<'a, G: Scope, T: Timestamp, D: Clone+'static, R: Clone+'static, C: Container> Collection<Child<'a, G, T>, D, R, C>
 where
-    C: traits::Leave<T, G::Timestamp, OuterContainer: Container>,
+    C: containers::Leave<T, G::Timestamp, OuterContainer: Container>,
     T: Refines<<G as ScopeParent>::Timestamp>,
 {
     /// Returns the final value of a Collection from a nested scope to its containing scope.
@@ -620,7 +619,7 @@ where
     ///     data.assert_eq(&result);
     /// });
     /// ```
-    pub fn leave(&self) -> Collection<G, D, R, <C as traits::Leave<T, G::Timestamp>>::OuterContainer> {
+    pub fn leave(&self) -> Collection<G, D, R, <C as containers::Leave<T, G::Timestamp>>::OuterContainer> {
         use timely::dataflow::channels::pact::Pipeline;
         self.inner
             .leave()
@@ -733,7 +732,7 @@ where
 }
 
 /// Traits that can be implemented by containers to provide functionality to collections based on them.
-pub mod traits {
+pub mod containers {
 
     use timely::progress::{Timestamp, timestamp::Refines};
     use crate::collection::Abelian;
@@ -791,4 +790,4 @@ pub mod traits {
             self.into_iter().filter_map(move |(d,t,r)| step.results_in(&t).map(|t| (d,t,r))).collect()
         }
     }
-}
+}

differential-dataflow/src/operators/iterate.rs

@@ -167,7 +167,7 @@ where
 impl<G, D: Data, R: Abelian, C: Container> Variable<G, D, R, C>
 where
     G: Scope<Timestamp: Lattice>,
-    C: crate::collection::traits::Negate + crate::collection::traits::ResultsIn<<G::Timestamp as Timestamp>::Summary>,
+    C: crate::collection::containers::Negate + crate::collection::containers::ResultsIn<<G::Timestamp as Timestamp>::Summary>,
 {
     /// Creates a new initially empty `Variable`.
     ///
@@ -246,7 +246,7 @@ where
 impl<G, D: Data, R: Semigroup, C: Container> SemigroupVariable<G, D, R, C>
 where
     G: Scope<Timestamp: Lattice>,
-    C: crate::collection::traits::ResultsIn<<G::Timestamp as Timestamp>::Summary>,
+    C: crate::collection::containers::ResultsIn<<G::Timestamp as Timestamp>::Summary>,
 {
     /// Creates a new initially empty `SemigroupVariable`.
     pub fn new(scope: &mut G, step: <G::Timestamp as Timestamp>::Summary) -> Self {