Remove into_owned.rs

Author: frankmcsherry

differential-dataflow/src/into_owned.rs

@@ -79,7 +79,6 @@ use std::fmt::Debug;
 pub use collection::{Collection, AsCollection};
 pub use hashable::Hashable;
 pub use difference::Abelian as Diff;
-pub use into_owned::IntoOwned;
 
 /// Data type usable in differential dataflow.
 ///
@@ -106,7 +105,6 @@ pub mod logging;
 pub mod consolidation;
 pub mod capture;
 pub mod containers;
-mod into_owned;
 
 /// Configuration options for differential dataflow.
 #[derive(Default)]

differential-dataflow/src/lib.rs

@@ -26,7 +26,7 @@ use timely::progress::Timestamp;
 use timely::progress::Antichain;
 use timely::dataflow::operators::Capability;
 
-use crate::{Data, ExchangeData, Collection, AsCollection, Hashable, IntoOwned};
+use crate::{Data, ExchangeData, Collection, AsCollection, Hashable};
 use crate::difference::Semigroup;
 use crate::lattice::Lattice;
 use crate::trace::{self, Trace, TraceReader, BatchReader, Batcher, Builder, Cursor};
@@ -285,10 +285,11 @@ where
     /// A direct implementation of `ReduceCore::reduce_abelian`.
     pub fn reduce_abelian<L, K, V, Bu, T2>(&self, name: &str, mut logic: L) -> Arranged<G, TraceAgent<T2>>
     where
-        for<'a> T1::Key<'a>: IntoOwned<'a, Owned = K>,
+        T1: TraceReader<KeyOwn = K>,
         T2: for<'a> Trace<
             Key<'a>= T1::Key<'a>,
-            Val<'a> : IntoOwned<'a, Owned = V>,
+            KeyOwn = K,
+            ValOwn = V,
             Time=T1::Time,
             Diff: Abelian,
         >+'static,
@@ -309,10 +310,11 @@ where
     /// A direct implementation of `ReduceCore::reduce_core`.
     pub fn reduce_core<L, K, V, Bu, T2>(&self, name: &str, logic: L) -> Arranged<G, TraceAgent<T2>>
     where
-        for<'a> T1::Key<'a>: IntoOwned<'a, Owned = K>,
+        T1: TraceReader<KeyOwn = K>,
         T2: for<'a> Trace<
             Key<'a>=T1::Key<'a>,
-            Val<'a> : IntoOwned<'a, Owned = V>,
+            KeyOwn = K,
+            ValOwn = V,
             Time=T1::Time,
         >+'static,
         K: Ord + 'static,

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

@@ -111,7 +111,9 @@ use timely::dataflow::operators::Capability;
 use crate::operators::arrange::arrangement::Arranged;
 use crate::trace::{Builder, Description};
 use crate::trace::{self, Trace, TraceReader, Cursor};
-use crate::{ExchangeData, Hashable, IntoOwned};
+use crate::{ExchangeData, Hashable};
+
+use crate::trace::implementations::containers::BatchContainer;
 
 use super::TraceAgent;
 
@@ -131,9 +133,9 @@ pub fn arrange_from_upsert<G, K, V, Bu, Tr>(
 ) -> Arranged<G, TraceAgent<Tr>>
 where
     G: Scope<Timestamp=Tr::Time>,
-    Tr: Trace + for<'a> TraceReader<
-        Key<'a> : IntoOwned<'a, Owned = K>,
-        Val<'a> : IntoOwned<'a, Owned = V>,
+    Tr: for<'a> Trace<
+        KeyOwn = K,
+        ValOwn = V,
         Time: TotalOrder+ExchangeData,
         Diff=isize,
     >+'static,
@@ -148,7 +150,7 @@ where
 
         let reader = &mut reader;
 
-        let exchange = Exchange::new(move |update: &(K,Option<V>,G::Timestamp)| (update.0).hashed().into());
+        let exchange = Exchange::<(K, Option<V>, G::Timestamp), _>::new(move |update: &(K,Option<V>,G::Timestamp)| (update.0).hashed().into());
 
         stream.unary_frontier(exchange, name, move |_capability, info| {
 
@@ -239,16 +241,16 @@ where
                                     let mut prev_value: Option<V> = None;
 
                                     // Attempt to find the key in the trace.
-                                    trace_cursor.seek_key(&trace_storage, IntoOwned::borrow_as(&key));
-                                    if trace_cursor.get_key(&trace_storage).map(|k| k.eq(&IntoOwned::borrow_as(&key))).unwrap_or(false) {
+                                    trace_cursor.seek_key(&trace_storage, Tr::KeyContainer::borrow_as(&key));
+                                    if trace_cursor.get_key(&trace_storage).map(|k| k.eq(&Tr::KeyContainer::borrow_as(&key))).unwrap_or(false) {
                                         // Determine the prior value associated with the key.
                                         while let Some(val) = trace_cursor.get_val(&trace_storage) {
                                             let mut count = 0;
                                             trace_cursor.map_times(&trace_storage, |_time, diff| count += Tr::owned_diff(diff));
                                             assert!(count == 0 || count == 1);
                                             if count == 1 {
                                                 assert!(prev_value.is_none());
-                                                prev_value = Some(val.into_owned());
+                                                prev_value = Some(Tr::owned_val(val));
                                             }
                                             trace_cursor.step_val(&trace_storage);
                                         }