Correct cargo doc glitches

Author: frankmcsherry

advent_of_code_2017/src/bin/day_07.rs

@@ -3,7 +3,7 @@ extern crate differential_dataflow;
 
 // taken from: https://adventofcode.com/2017/day/6
 
-use differential_dataflow::Collection;
+use differential_dataflow::VecCollection;
 use differential_dataflow::input::Input;
 use differential_dataflow::operators::*;
 

advent_of_code_2017/src/bin/day_08.rs

@@ -3,7 +3,7 @@ extern crate differential_dataflow;
 
 // taken from: https://adventofcode.com/2017/day/8
 
-// use differential_dataflow::Collection;
+// use differential_dataflow::VecCollection;
 use differential_dataflow::input::Input;
 use differential_dataflow::operators::*;
 use differential_dataflow::algorithms::prefix_sum::PrefixSum;
@@ -1068,7 +1068,7 @@ wui inc -120 if i > -2038";
             let edits = data.map(|(pos, line)| {
 
                 // Each line has a read location with a condition, and a write location with an operation.
-                // E.g., 
+                // E.g.,
                 //
                 //      kxm dec 986 if xbh <= -2515
                 //      obc inc 63 if wui >= 2800

advent_of_code_2017/src/bin/day_10.rs

@@ -3,7 +3,7 @@ extern crate differential_dataflow;
 
 // taken from: https://adventofcode.com/2017/day/8
 
-use differential_dataflow::Collection;
+use differential_dataflow::VecCollection;
 use differential_dataflow::input::Input;
 use differential_dataflow::operators::*;
 
@@ -61,4 +61,4 @@ fn knot_step<I: Iterator<Item=u8>+Clone>(iter: I, rounds: usize) -> Vec<u8> {
     }
 
     state
-}
+}

advent_of_code_2017/src/bin/day_14.rs

@@ -3,7 +3,7 @@ extern crate differential_dataflow;
 
 // taken from: https://adventofcode.com/2017/day/8
 
-use differential_dataflow::Collection;
+use differential_dataflow::VecCollection;
 use differential_dataflow::input::Input;
 use differential_dataflow::operators::*;
 
@@ -31,8 +31,8 @@ fn main() {
                     // println!("{:?}: \t{:?}", row, hash);
 
                     (0 .. 128)
-                        .map(move |col| 
-                            if hash[col/8] & (1 << (7-(col % 8))) != 0 { 
+                        .map(move |col|
+                            if hash[col/8] & (1 << (7-(col % 8))) != 0 {
                                 (row, col, '#')
                             }
                             else {
@@ -92,4 +92,4 @@ fn knot_step<I: Iterator<Item=u8>+Clone>(iter: I, rounds: usize) -> Vec<u8> {
     }
 
     state
-}
+}

advent_of_code_2017/src/bin/day_15.rs

@@ -3,7 +3,7 @@ extern crate differential_dataflow;
 
 // taken from: https://adventofcode.com/2017/day/8
 
-use differential_dataflow::Collection;
+use differential_dataflow::VecCollection;
 use differential_dataflow::input::Input;
 use differential_dataflow::operators::*;
 
@@ -43,4 +43,4 @@ fn main() {
 
     println!("part2: {:?}", equal);
 
-}
+}

differential-dataflow/src/algorithms/graphs/propagate.rs

@@ -51,7 +51,7 @@ use crate::operators::arrange::arrangement::Arranged;
 ///
 /// This variant takes a pre-arranged edge collection, to facilitate re-use, and allows
 /// a method `logic` to specify the rounds in which we introduce various labels. The output
-/// of `logic should be a number in the interval [0,64],
+/// of `logic should be a number in the interval \[0,64\],
 pub fn propagate_core<G, N, L, Tr, F, R>(edges: &Arranged<G,Tr>, nodes: &VecCollection<G,(N,L),R>, logic: F) -> VecCollection<G,(N,L),R>
 where
     G: Scope<Timestamp=Tr::Time>,

differential-dataflow/src/collection.rs

@@ -22,7 +22,7 @@ use crate::difference::{Semigroup, Abelian, Multiply};
 use crate::lattice::Lattice;
 use crate::hashable::Hashable;
 
-/// A mutable collection of values of type `D`
+/// An evolving collection of values of type `D`, backed by Rust `Vec` types as containers.
 ///
 /// The `Collection` type is the core abstraction in differential dataflow programs. As you write your
 /// differential dataflow computation, you write as if the collection is a static dataset to which you
@@ -31,15 +31,17 @@ use crate::hashable::Hashable;
 /// propagate changes through your functional computation and report the corresponding changes to the
 /// output collections.
 ///
-/// Each collection has three generic parameters. The parameter `G` is for the scope in which the
+/// Each vec collection has three generic parameters. The parameter `G` is for the scope in which the
 /// collection exists; as you write more complicated programs you may wish to introduce nested scopes
 /// (e.g. for iteration) and this parameter tracks the scope (for timely dataflow's benefit). The `D`
 /// parameter is the type of data in your collection, for example `String`, or `(u32, Vec<Option<()>>)`.
 /// The `R` parameter represents the types of changes that the data undergo, and is most commonly (and
 /// defaults to) `isize`, representing changes to the occurrence count of each record.
+///
+/// This type definition instantiates the [`Collection`] type with a `Vec<(D, G::Timestamp, R)>`.
 pub type VecCollection<G, D, R = isize> = Collection<G, Vec<(D, <G as ScopeParent>::Timestamp, R)>>;
 
-/// A collection represented by a stream of abstract containers.
+/// An evolving collection represented by a stream of abstract containers.
 ///
 /// The containers purport to reperesent changes to a collection, and they must implement various traits
 /// in order to expose some of this functionality (e.g. negation, timestamp manipulation). Other actions

differential-dataflow/src/operators/arrange/upsert.rs

@@ -119,7 +119,7 @@ use super::TraceAgent;
 
 /// Arrange data from a stream of keyed upserts.
 ///
-/// The input should be a stream of timestamped pairs of Key and Option<Val>.
+/// The input should be a stream of timestamped pairs of `Key` and `Option<Val>`.
 /// The contents of the collection are defined key-by-key, where each optional
 /// value in sequence either replaces or removes the existing value, should it
 /// exist.

differential-dataflow/src/trace/implementations/chainless_batcher.rs

@@ -1,14 +1,4 @@
 //! A `Batcher` implementation based on merge sort.
-//!
-//! The `MergeBatcher` requires support from two types, a "chunker" and a "merger".
-//! The chunker receives input batches and consolidates them, producing sorted output
-//! "chunks" that are fully consolidated (no adjacent updates can be accumulated).
-//! The merger implements the [`Merger`] trait, and provides hooks for manipulating
-//! sorted "chains" of chunks as needed by the merge batcher: merging chunks and also
-//! splitting them apart based on time.
-//!
-//! Implementations of `MergeBatcher` can be instantiated through the choice of both
-//! the chunker and the merger, provided their respective output and input types align.
 
 use timely::progress::frontier::AntichainRef;
 use timely::progress::{frontier::Antichain, Timestamp};

differential-dataflow/src/trace/implementations/merge_batcher.rs

@@ -292,7 +292,7 @@ pub mod container {
 
     /// A merger for arbitrary containers.
     ///
-    /// `MC` is a [`Container`] that implements [`MergerChunk`].
+    /// `MC` is a `Container` that implements [`MergerChunk`].
     /// `CQ` is a [`ContainerQueue`] supporting `MC`.
     pub struct ContainerMerger<MC, CQ> {
         _marker: PhantomData<(MC, CQ)>,