Bring back Container trait

It's a composite trait requiring WithProgress, Default, Clone, 'static

Signed-off-by: Moritz Hoffmann <[email protected]>

Author: antiguru

container/src/lib.rs

@@ -17,7 +17,7 @@ use std::collections::VecDeque;
 // for containers that implement `Default`, and we use the associated `::Container` all over Timely.
 // We can only access the type if all requirements for the `ContainerBuilder` implementation are
 // satisfied.
-pub trait WithProgress: Default {
+pub trait WithProgress {
     /// The number of updates
     ///
     /// This number is used in progress tracking to confirm the receipt of some number
@@ -52,7 +52,7 @@ pub trait DrainContainer {
 }
 
 /// A container that can be sized and reveals its capacity.
-pub trait SizableContainer: WithProgress {
+pub trait SizableContainer: Sized {
     /// Indicates that the container is "full" and should be shipped.
     fn at_capacity(&self) -> bool;
     /// Restores `self` to its desired capacity, if it has one.
@@ -96,7 +96,7 @@ pub trait ContainerBuilder: Default + 'static {
     /// The container type we're building.
     // The container is `Clone` because `Tee` requires it, otherwise we need to repeat it
     // all over Timely. `'static` because we don't want lifetimes everywhere.
-    type Container: WithProgress + Clone + 'static;
+    type Container: WithProgress + Default + Clone + 'static;
     /// Extract assembled containers, potentially leaving unfinished data behind. Can
     /// be called repeatedly, for example while the caller can send data.
     ///
@@ -152,7 +152,7 @@ pub struct CapacityContainerBuilder<C>{
     pending: VecDeque<C>,
 }
 
-impl<T, C: SizableContainer + PushInto<T>> PushInto<T> for CapacityContainerBuilder<C> {
+impl<T, C: SizableContainer + Default + PushInto<T>> PushInto<T> for CapacityContainerBuilder<C> {
     #[inline]
     fn push_into(&mut self, item: T) {
         // Ensure capacity
@@ -168,7 +168,7 @@ impl<T, C: SizableContainer + PushInto<T>> PushInto<T> for CapacityContainerBuil
     }
 }
 
-impl<C: WithProgress + Clone + 'static> ContainerBuilder for CapacityContainerBuilder<C> {
+impl<C: WithProgress + Default + Clone + 'static> ContainerBuilder for CapacityContainerBuilder<C> {
     type Container = C;
 
     #[inline]
@@ -191,7 +191,7 @@ impl<C: WithProgress + Clone + 'static> ContainerBuilder for CapacityContainerBu
     }
 }
 
-impl<C: WithProgress + Clone + 'static> LengthPreservingContainerBuilder for CapacityContainerBuilder<C> { }
+impl<C: WithProgress + SizableContainer + Default + Clone + 'static> LengthPreservingContainerBuilder for CapacityContainerBuilder<C> { }
 
 impl<T> WithProgress for Vec<T> {
     #[inline] fn update_count(&self) -> i64 { i64::try_from(Vec::len(self)).unwrap() }

timely/src/dataflow/channels/mod.rs

@@ -2,7 +2,7 @@
 
 use serde::{Deserialize, Serialize};
 use crate::communication::Push;
-use crate::WithProgress;
+use crate::Container;
 
 /// A collection of types that may be pushed at.
 pub mod pushers;
@@ -32,7 +32,7 @@ impl<T, C> Message<T, C> {
     }
 }
 
-impl<T, C: WithProgress> Message<T, C> {
+impl<T, C: Container> Message<T, C> {
     /// Creates a new message instance from arguments.
     pub fn new(time: T, data: C, from: usize, seq: usize) -> Self {
         Message { time, data, from, seq }

timely/src/dataflow/channels/pact.rs

@@ -19,7 +19,6 @@ use crate::dataflow::channels::Message;
 use crate::logging::{TimelyLogger as Logger, MessagesEvent};
 use crate::progress::Timestamp;
 use crate::worker::AsWorker;
-use crate::Data;
 
 /// A `ParallelizationContract` allocates paired `Push` and `Pull` implementors.
 pub trait ParallelizationContract<T, C> {
@@ -86,7 +85,7 @@ where
     CB: ContainerBuilder,
     CB::Container: DrainContainer,
     CB: for<'a> PushInto<<CB::Container as DrainContainer>::Item<'a>>,
-    CB::Container: Data + Send + crate::dataflow::channels::ContainerBytes,
+    CB::Container: Send + crate::dataflow::channels::ContainerBytes,
     for<'a> H: FnMut(&<CB::Container as DrainContainer>::Item<'a>) -> u64
 {
     type Pusher = ExchangePusher<T, CB, LogPusher<Box<dyn Push<Message<T, CB::Container>>>>, H>;

timely/src/dataflow/channels/pullers/counter.rs

@@ -9,7 +9,7 @@ use crate::communication::Pull;
 use crate::WithProgress;
 
 /// A wrapper which accounts records pulled past in a shared count map.
-pub struct Counter<T: Ord+Clone+'static, C, P: Pull<Message<T, C>>> {
+pub struct Counter<T, C, P> {
     pullable: P,
     consumed: Rc<RefCell<ChangeBatch<T>>>,
     phantom: ::std::marker::PhantomData<C>,

timely/src/dataflow/channels/pushers/buffer.rs

@@ -6,7 +6,7 @@ use crate::container::{ContainerBuilder, CapacityContainerBuilder, PushInto};
 use crate::dataflow::channels::Message;
 use crate::dataflow::operators::Capability;
 use crate::progress::Timestamp;
-use crate::{WithProgress, Data};
+use crate::{Container, WithProgress};
 
 /// Buffers data sent at the same time, for efficient communication.
 ///
@@ -44,7 +44,7 @@ impl<T, CB: Default, P> Buffer<T, CB, P> {
     }
 }
 
-impl<T, C: WithProgress + Data, P: Push<Message<T, C>>> Buffer<T, CapacityContainerBuilder<C>, P> where T: Eq+Clone {
+impl<T, C: Container, P: Push<Message<T, C>>> Buffer<T, CapacityContainerBuilder<C>, P> where T: Eq+Clone {
     /// Returns a `Session`, which accepts data to send at the associated time
     #[inline]
     pub fn session(&mut self, time: &T) -> Session<'_, T, CapacityContainerBuilder<C>, P> {

timely/src/dataflow/channels/pushers/tee.rs

@@ -7,7 +7,7 @@ use std::rc::Rc;
 use crate::dataflow::channels::Message;
 
 use crate::communication::Push;
-use crate::{WithProgress, Data};
+use crate::{Container, Data};
 
 type PushList<T, C> = Rc<RefCell<Vec<Box<dyn Push<Message<T, C>>>>>>;
 
@@ -17,7 +17,7 @@ pub struct Tee<T, C> {
     shared: PushList<T, C>,
 }
 
-impl<T: Data, C: WithProgress + Data> Push<Message<T, C>> for Tee<T, C> {
+impl<T: Data, C: Container> Push<Message<T, C>> for Tee<T, C> {
     #[inline]
     fn push(&mut self, message: &mut Option<Message<T, C>>) {
         let mut pushers = self.shared.borrow_mut();
@@ -32,14 +32,14 @@ impl<T: Data, C: WithProgress + Data> Push<Message<T, C>> for Tee<T, C> {
                 pushers[index-1].push(&mut None);
             }
         }
-        if pushers.len() > 0 {
+        if !pushers.is_empty() {
             let last = pushers.len() - 1;
             pushers[last].push(message);
         }
     }
 }
 
-impl<T, C: WithProgress> Tee<T, C> {
+impl<T, C: Default> Tee<T, C> {
     /// Allocates a new pair of `Tee` and `TeeHelper`.
     pub fn new() -> (Tee<T, C>, TeeHelper<T, C>) {
         let shared = Rc::new(RefCell::new(Vec::new()));
@@ -52,7 +52,7 @@ impl<T, C: WithProgress> Tee<T, C> {
     }
 }
 
-impl<T, C: WithProgress> Clone for Tee<T, C> {
+impl<T, C: Default> Clone for Tee<T, C> {
     fn clone(&self) -> Self {
         Self {
             buffer: Default::default(),

timely/src/dataflow/operators/branch.rs

@@ -3,7 +3,7 @@
 use crate::dataflow::channels::pact::Pipeline;
 use crate::dataflow::operators::generic::builder_rc::OperatorBuilder;
 use crate::dataflow::{Scope, Stream, StreamCore};
-use crate::{WithProgress, Data};
+use crate::{Container, Data};
 
 /// Extension trait for `Stream`.
 pub trait Branch<S: Scope, D: Data> {
@@ -93,7 +93,7 @@ pub trait BranchWhen<T>: Sized {
     fn branch_when(&self, condition: impl Fn(&T) -> bool + 'static) -> (Self, Self);
 }
 
-impl<S: Scope, C: WithProgress + Data> BranchWhen<S::Timestamp> for StreamCore<S, C> {
+impl<S: Scope, C: Container> BranchWhen<S::Timestamp> for StreamCore<S, C> {
     fn branch_when(&self, condition: impl Fn(&S::Timestamp) -> bool + 'static) -> (Self, Self) {
         let mut builder = OperatorBuilder::new("Branch".to_owned(), self.scope());
         builder.set_notify(false);

timely/src/dataflow/operators/core/capture/capture.rs

@@ -10,14 +10,14 @@ use crate::dataflow::channels::pact::Pipeline;
 use crate::dataflow::channels::pullers::Counter as PullCounter;
 use crate::dataflow::operators::generic::builder_raw::OperatorBuilder;
 
-use crate::{WithProgress, Data};
+use crate::Container;
 use crate::progress::ChangeBatch;
 use crate::progress::Timestamp;
 
 use super::{Event, EventPusher};
 
 /// Capture a stream of timestamped data for later replay.
-pub trait Capture<T: Timestamp, C: WithProgress + Data> {
+pub trait Capture<T: Timestamp, C: Container> {
     /// Captures a stream of timestamped data for later replay.
     ///
     /// # Examples
@@ -113,7 +113,7 @@ pub trait Capture<T: Timestamp, C: WithProgress + Data> {
     }
 }
 
-impl<S: Scope, C: WithProgress + Data> Capture<S::Timestamp, C> for StreamCore<S, C> {
+impl<S: Scope, C: Container> Capture<S::Timestamp, C> for StreamCore<S, C> {
     fn capture_into<P: EventPusher<S::Timestamp, C>+'static>(&self, mut event_pusher: P) {
 
         let mut builder = OperatorBuilder::new("Capture".to_owned(), self.scope());

timely/src/dataflow/operators/core/capture/extract.rs

@@ -1,6 +1,7 @@
 //! Traits and types for extracting captured timely dataflow streams.
 
 use super::Event;
+use crate::Container;
 use crate::container::{SizableContainer, DrainContainer, PushInto};
 
 /// Supports extracting a sequence of timestamp and data.
@@ -50,7 +51,7 @@ pub trait Extract<T, C> {
 
 impl<T, C> Extract<T, C> for ::std::sync::mpsc::Receiver<Event<T, C>>
 where
-    for<'a> C: SizableContainer + DrainContainer<Item<'a>: Ord> + PushInto<C::Item<'a>>,
+    for<'a> C: Container + SizableContainer + DrainContainer<Item<'a>: Ord> + PushInto<C::Item<'a>>,
     T: Ord,
 {
     fn extract(self) -> Vec<(T, C)> {

timely/src/dataflow/operators/core/capture/replay.rs

@@ -46,7 +46,7 @@ use crate::progress::Timestamp;
 
 use super::Event;
 use super::event::EventIterator;
-use crate::WithProgress;
+use crate::Container;
 
 /// Replay a capture stream into a scope with the same timestamp.
 pub trait Replay<T: Timestamp, C> : Sized {
@@ -62,7 +62,7 @@ pub trait Replay<T: Timestamp, C> : Sized {
     fn replay_core<S: Scope<Timestamp=T>>(self, scope: &mut S, period: Option<std::time::Duration>) -> StreamCore<S, C>;
 }
 
-impl<T: Timestamp, C: WithProgress + Clone + 'static, I> Replay<T, C> for I
+impl<T: Timestamp, C: Container, I> Replay<T, C> for I
 where
     I : IntoIterator,
     <I as IntoIterator>::Item: EventIterator<T, C>+'static,