Correct cargo doc glitches

Author: frankmcsherry

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)>,