Fix typos (#521)

Author: waywardmonkeys

dogsdogsdogs/src/operators/half_join.rs

@@ -26,7 +26,7 @@
 //! collections.
 //!
 //! There are some caveats about ties, and we should treat each `time` for
-//! each input as occuring at distinct times, one after the other (so that
+//! each input as occurring at distinct times, one after the other (so that
 //! ties are resolved by the index of the input). There is also the matter
 //! of logical compaction, which should not be done in a way that prevents
 //! the correct determination of the total order comparison.

doop/src/main.rs

@@ -1199,7 +1199,7 @@ fn main() {
 
             while probe.less_than(inputs.0[0].time()) { worker.step(); }
 
-            println!("{:?}\tcomputation initalized", timer.elapsed());
+            println!("{:?}\tcomputation initialized", timer.elapsed());
 
             if batch > 0 {
 

examples/projekt.rs

@@ -109,7 +109,7 @@ fn main() {
 
         });
 
-        // Introduce XY projektion.
+        // Introduce XY projection.
         xy_goal.insert((0, 0));
         xy_goal.insert((0, 1));
         xy_goal.insert((0, 3));
@@ -125,7 +125,7 @@ fn main() {
         xy_goal.insert((4, 1));
         xy_goal.insert((4, 2));
 
-        // Introduce XZ projektion.
+        // Introduce XZ projection.
         xz_goal.insert((0, 2));
         xz_goal.insert((0, 3));
         xz_goal.insert((0, 4));

examples/spines.rs

@@ -72,7 +72,7 @@ fn main() {
                         .probe_with(&mut probe);
                 }
                 _ => {
-                    println!("unreconized mode: {:?}", mode)
+                    println!("unrecognized mode: {:?}", mode)
                 }
             }
 

interactive/src/plan/sfw.rs

@@ -35,7 +35,7 @@ use differential_dataflow::{Collection, ExchangeData};
 use crate::plan::{Plan, Render};
 use crate::{TraceManager, Time, Diff, Datum};
 
-/// A multiway join of muliple relations.
+/// A multiway join of multiple relations.
 ///
 /// By expressing multiple relations and required equivalances between their attributes,
 /// we can more efficiently design incremental update strategies without materializing

server/src/lib.rs

@@ -32,7 +32,7 @@ pub type Environment<'a, 'b> = (
 ///
 /// This type is meant to be a smart pointer for a type `T` that needs to keep
 /// a `Library` alive, perhaps because its methods would call in to the library.
-/// The type should have a specified drop order (viz RFC 1857) which guarentees
+/// The type should have a specified drop order (viz RFC 1857) which guarantees
 /// that the shared library reference drops only after the element itself is
 /// dropped. It also implements `Deref` and `DerefMut` to provide the experience
 /// of a `T` itself.

src/algorithms/identifiers.rs

@@ -52,7 +52,7 @@ where
         // additions and subtractions of losers, rather than reproducing
         // the winners. This is done under the premise that losers are
         // very rare, and maintaining winners in both the input and output
-        // of `reduce` is an unneccesary duplication.
+        // of `reduce` is an unnecessary duplication.
 
         use crate::collection::AsCollection;
 

src/consolidation.rs

@@ -322,7 +322,7 @@ pub fn consolidate_container<C: ConsolidateLayout>(container: &mut C, target: &m
     for item in permutation.drain(..) {
         let (key, diff) = C::into_parts(item);
         match &mut previous {
-            // Initial iteration, remeber key and diff.
+            // Initial iteration, remember key and diff.
             // TODO: Opportunity for GatCow for diff.
             None => previous = Some((key, diff.into_owned())),
             Some((prevkey, d)) => {

src/dynamic/pointstamp.rs

@@ -68,7 +68,7 @@ impl<T: Timestamp> PointStamp<T> {
     /// Returns the wrapped vector.
     ///
     /// This method is the support way to mutate the contents of `self`, by extracting 
-    /// the vector and then re-introducting it with `PointStamp::new` to re-establish 
+    /// the vector and then re-introducing it with `PointStamp::new` to re-establish
     /// the invariant that the vector not end with `T::minimum`.
     pub fn into_vec(self) -> Vec<T> {
         self.vector
@@ -196,7 +196,7 @@ impl<T: Timestamp> PathSummary<PointStamp<T>> for PointStampSummary<T::Summary>
 impl<TS: PartialOrder> PartialOrder for PointStampSummary<TS> {
     fn less_equal(&self, other: &Self) -> bool {
         // If the `retain`s are not the same, there is some coordinate which
-        // could either be bigger or smaller as the timestamp or the replacemnt.
+        // could either be bigger or smaller as the timestamp or the replacement.
         // In principle, a `T::minimum()` extension could break this rule, and
         // we could tighten this logic if needed; I think it is fine not to though.
         self.retain == other.retain

src/logging.rs

@@ -95,7 +95,7 @@ impl From<MergeEvent> for DifferentialEvent { fn from(e: MergeEvent) -> Self { D
 /// A merge failed to complete in time.
 #[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Serialize, Deserialize)]
 pub struct MergeShortfall {
-    /// Operator identifer.
+    /// Operator identifier.
     pub operator: usize,
     /// Which order of magnitude.
     pub scale: usize,