Steps needed to remove boxing from view/table ops

Sadly these do not work yet due to the ICE from
rust-lang/rust#53443

Author: jonhoo

.travis.yml

@@ -2,7 +2,7 @@ dist: trusty
 language: rust
 cache: cargo
 rust:
-  - nightly-2019-01-10
+  - nightly-2019-01-21
 env:
   - SETTLE_TIME=2000
 script:

noria-benchmarks/vote/orchestrator.rs

@@ -900,7 +900,7 @@ fn run_clients(
             any_not_overloaded = false;
         } else if !stderr.is_empty() {
             eprintln!("{} reported:", host);
-            let stderr = stderr.trim_right().replace('\n', "\n > ");
+            let stderr = stderr.trim_end().replace('\n', "\n > ");
             eprintln!(" > {}", stderr);
         }
     }
@@ -969,7 +969,7 @@ fn ec2_instance_type_cores(it: &str) -> Option<u16> {
         "nano" | "micro" | "small" => Some(1),
         "medium" | "large" => Some(2),
         t if t.ends_with("xlarge") => {
-            let mult = t.trim_right_matches("xlarge").parse::<u16>().unwrap_or(1);
+            let mult = t.trim_end_matches("xlarge").parse::<u16>().unwrap_or(1);
             Some(4 * mult)
         }
         _ => None,

noria-server/dataflow/src/lib.rs

@@ -1,7 +1,6 @@
 #![feature(nll)]
 #![feature(box_syntax)]
 #![feature(box_patterns)]
-#![feature(if_while_or_patterns)]
 #![deny(unused_extern_crates)]
 
 #[cfg(debug_assertions)]

noria/src/table.rs

@@ -34,14 +34,14 @@ pub struct TableEndpoint(SocketAddr);
 impl Service<()> for TableEndpoint {
     type Response = multiplex::MultiplexTransport<Transport, Tagger>;
     type Error = tokio::io::Error;
-    type Future = Box<Future<Item = Self::Response, Error = Self::Error> + Send>;
+    // have to repeat types because https://github.com/rust-lang/rust/issues/57807
+    existential type Future: Future<Item = multiplex::MultiplexTransport<Transport, Tagger>, Error = tokio::io::Error>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         Ok(Async::Ready(()))
     }
 
     fn call(&mut self, _: ()) -> Self::Future {
-        Box::new(
             tokio::net::TcpStream::connect(&self.0)
                 .and_then(|s| {
                     s.set_nodelay(true)?;
@@ -54,8 +54,7 @@ impl Service<()> for TableEndpoint {
                 })
                 .map(AsyncBincodeStream::from)
                 .map(AsyncBincodeStream::for_async)
-                .map(|t| multiplex::MultiplexTransport::new(t, Tagger::default())),
-        )
+                .map(|t| multiplex::MultiplexTransport::new(t, Tagger::default()))
     }
 }
 
@@ -261,8 +260,8 @@ impl fmt::Debug for Table {
 impl Service<Input> for Table {
     type Error = TableError;
     type Response = <TableRpc as Service<Tagged<LocalOrNot<Input>>>>::Response;
-    // existential once https://github.com/rust-lang/rust/issues/53443 is fixed
-    type Future = Box<Future<Item = Tagged<()>, Error = Self::Error> + Send>;
+    // have to repeat types because https://github.com/rust-lang/rust/issues/57807
+    existential type Future: Future<Item = Tagged<()>, Error = TableError>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         for s in &mut self.shards {
@@ -277,8 +276,7 @@ impl Service<Input> for Table {
         // TODO: check each row's .len() against self.columns.len() -> WrongColumnCount
 
         if self.shards.len() == 1 {
-            // when Box goes away, this becomes future::Either::A
-            Box::new(
+            future::Either::A(
                 self.shards[0]
                     .call(
                         if self.dst_is_local {
@@ -337,8 +335,7 @@ impl Service<Input> for Table {
                 }
             }
 
-            // when Box goes away, this becomes future::Either::B
-            Box::new(
+            future::Either::B(
                 wait_for
                     .fold((), |_, _| Ok(()))
                     .map_err(TableError::from)
@@ -487,14 +484,12 @@ impl Table {
     fn quick_n_dirty<Request>(
         self,
         r: Request,
-    ) -> Box<Future<Item = Self, Error = AsyncTableError> + Send>
+    ) -> impl Future<Item = Table, Error = AsyncTableError> + Send
     where
         Request: Send + 'static,
         Self: Service<Request, Error = TableError>,
         <Self as Service<Request>>::Future: Send,
     {
-        // Box is needed for https://github.com/rust-lang/rust/issues/53984
-        Box::new(
             self.ready()
                 .map_err(|e| match e {
                     TableError::TransportError(e) => AsyncTableError::from(e),
@@ -508,8 +503,7 @@ impl Table {
                             error: e,
                         }),
                     })
-                }),
-        )
+                })
     }
 
     /// Insert a single row of data into this base table.
@@ -556,25 +550,25 @@ impl Table {
 
         if key.len() != self.key.len() {
             let error = TableError::WrongKeyColumnCount(self.key.len(), key.len());
-            return Box::new(future::err(AsyncTableError {
+            return future::Either::A(future::err(AsyncTableError {
                 table: Some(self),
                 error,
-            })) as Box<_>;
+            }));
         }
 
         let mut set = vec![Modification::None; self.columns.len()];
         for (coli, m) in u {
             if coli >= self.columns.len() {
                 let error = TableError::WrongColumnCount(self.columns.len(), coli + 1);
-                return Box::new(future::err(AsyncTableError {
+                return future::Either::A(future::err(AsyncTableError {
                     table: Some(self),
                     error,
-                })) as Box<_>;
+                }));
             }
             set[coli] = m;
         }
 
-        self.quick_n_dirty(TableOperation::Update { key, set })
+        future::Either::B(self.quick_n_dirty(TableOperation::Update { key, set }))
     }
 
     /// Perform a insert-or-update on this base table.
@@ -585,7 +579,7 @@ impl Table {
         self,
         insert: Vec<DataType>,
         update: V,
-    ) -> Box<Future<Item = Self, Error = AsyncTableError> + Send>
+    ) -> impl Future<Item = Table, Error = AsyncTableError> + Send
     where
         V: IntoIterator<Item = (usize, Modification)>,
     {
@@ -596,7 +590,7 @@ impl Table {
 
         if insert.len() != self.columns.len() {
             let error = TableError::WrongColumnCount(self.columns.len(), insert.len());
-            return Box::new(future::err(AsyncTableError {
+            return future::Either::A(future::err(AsyncTableError {
                 table: Some(self),
                 error,
             }));
@@ -606,18 +600,18 @@ impl Table {
         for (coli, m) in update {
             if coli >= self.columns.len() {
                 let error = TableError::WrongColumnCount(self.columns.len(), coli + 1);
-                return Box::new(future::err(AsyncTableError {
+                return future::Either::A(future::err(AsyncTableError {
                     table: Some(self),
                     error,
                 }));
             }
             set[coli] = m;
         }
 
-        self.quick_n_dirty(TableOperation::InsertOrUpdate {
+        future::Either::B(self.quick_n_dirty(TableOperation::InsertOrUpdate {
             row: insert,
             update: set,
-        })
+        }))
     }
 
     /// Trace the next modification to this base table.

noria/src/view.rs

@@ -30,23 +30,22 @@ pub struct ViewEndpoint(SocketAddr);
 impl Service<()> for ViewEndpoint {
     type Response = multiplex::MultiplexTransport<Transport, Tagger>;
     type Error = tokio::io::Error;
-    type Future = Box<Future<Item = Self::Response, Error = Self::Error> + Send>;
+    // have to repeat types because https://github.com/rust-lang/rust/issues/57807
+    existential type Future: Future<Item = multiplex::MultiplexTransport<Transport, Tagger>, Error = tokio::io::Error>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         Ok(Async::Ready(()))
     }
 
     fn call(&mut self, _: ()) -> Self::Future {
-        Box::new(
             tokio::net::TcpStream::connect(&self.0)
                 .and_then(|s| {
                     s.set_nodelay(true)?;
                     Ok(s)
                 })
                 .map(AsyncBincodeStream::from)
                 .map(AsyncBincodeStream::for_async)
-                .map(|t| multiplex::MultiplexTransport::new(t, Tagger::default())),
-        )
+                .map(|t| multiplex::MultiplexTransport::new(t, Tagger::default()))
     }
 }
 
@@ -214,8 +213,8 @@ impl fmt::Debug for View {
 impl Service<(Vec<Vec<DataType>>, bool)> for View {
     type Response = Vec<Datas>;
     type Error = ViewError;
-    // existential once https://github.com/rust-lang/rust/issues/53443 is fixed
-    type Future = Box<Future<Item = Self::Response, Error = Self::Error> + Send>;
+    // have to repeat types because https://github.com/rust-lang/rust/issues/57807
+    existential type Future: Future<Item = Vec<Datas>, Error = ViewError>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         for s in &mut self.shards {
@@ -234,7 +233,6 @@ impl Service<(Vec<Vec<DataType>>, bool)> for View {
         }
 
         let node = self.node;
-        Box::new(
             futures::stream::futures_ordered(
                 self.shards
                     .iter_mut()
@@ -259,8 +257,7 @@ impl Service<(Vec<Vec<DataType>>, bool)> for View {
                             })
                     }),
             )
-            .concat2(),
-        )
+            .concat2()
     }
 }
 

rust-toolchain

@@ -1 +1 @@
-nightly-2019-01-11
+nightly-2019-01-21