Emulate Try for stable rustc

Author: cuviper

src/iter/mod.rs

@@ -71,8 +71,8 @@ pub use either::Either;
 use std::cmp::{self, Ordering};
 use std::iter::{Sum, Product};
 use std::ops::Fn;
-use std::ops::Try;
 use self::plumbing::*;
+use self::private::Try;
 
 // There is a method to the madness here:
 //
@@ -2142,3 +2142,42 @@ pub trait ParallelExtend<T>
     /// ```
     fn par_extend<I>(&mut self, par_iter: I) where I: IntoParallelIterator<Item = T>;
 }
+
+/// We hide the `Try` trait in a private module, as it's only meant to be a
+/// stable clone of the standard library's `Try` trait, as yet unstable.
+mod private {
+    /// Clone of `std::ops::Try`.
+    ///
+    /// Implementing this trait is not permitted outside of `rayon`.
+    pub trait Try {
+        private_decl!{}
+
+        type Ok;
+        type Error;
+        fn into_result(self) -> Result<Self::Ok, Self::Error>;
+        fn from_ok(v: Self::Ok) -> Self;
+        fn from_error(v: Self::Error) -> Self;
+    }
+
+    impl<T> Try for Option<T> {
+        private_impl!{}
+
+        type Ok = T;
+        type Error = ();
+
+        fn into_result(self) -> Result<T, ()> { self.ok_or(()) }
+        fn from_ok(v: T) -> Self { Some(v) }
+        fn from_error(_: ()) -> Self { None }
+    }
+
+    impl<T, E> Try for Result<T, E> {
+        private_impl!{}
+
+        type Ok = T;
+        type Error = E;
+
+        fn into_result(self) -> Result<T, E> { self }
+        fn from_ok(v: T) -> Self { Ok(v) }
+        fn from_error(v: E) -> Self { Err(v) }
+    }
+}

src/iter/try_fold.rs

@@ -4,7 +4,7 @@ use super::*;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::fmt::{self, Debug};
 use std::marker::PhantomData;
-use std::ops::Try;
+use super::private::Try;
 
 pub fn try_fold<U, I, ID, F>(base: I, identity: ID, fold_op: F) -> TryFold<I, U, ID, F>
     where I: ParallelIterator,
@@ -148,7 +148,7 @@ impl<'r, C, U, F, T> Folder<T> for TryFoldFolder<'r, C, U, F>
         let fold_op = self.fold_op;
         let result = self.result.and_then(|mut acc| {
             for item in iter {
-                acc = fold_op(acc, item)?;
+                acc = fold_op(acc, item).into_result()?;
             }
             Ok(acc)
         });

src/iter/try_reduce.rs

@@ -1,7 +1,7 @@
 use super::ParallelIterator;
 use super::plumbing::*;
 
-use std::ops::Try;
+use super::private::Try;
 use std::sync::atomic::{AtomicBool, Ordering};
 
 pub fn try_reduce<PI, R, ID, T>(pi: PI, identity: ID, reduce_op: R) -> T
@@ -78,7 +78,10 @@ impl<'r, R, ID, T> Reducer<T> for TryReduceConsumer<'r, R, ID>
           T: Try
 {
     fn reduce(self, left: T, right: T) -> T {
-        (self.reduce_op)(left?, right?)
+        match (left.into_result(), right.into_result()) {
+            (Ok(left), Ok(right)) => (self.reduce_op)(left, right),
+            (Err(e), _) | (_, Err(e)) => T::from_error(e),
+        }
     }
 }
 
@@ -97,7 +100,7 @@ impl<'r, R, T> Folder<T> for TryReduceFolder<'r, R, T>
     fn consume(self, item: T) -> Self {
         let reduce_op = self.reduce_op;
         let result = self.result.and_then(|left| {
-            reduce_op(left, item?).into_result()
+            reduce_op(left, item.into_result()?).into_result()
         });
         TryReduceFolder {
             result: result,
@@ -111,7 +114,7 @@ impl<'r, R, T> Folder<T> for TryReduceFolder<'r, R, T>
         let reduce_op = self.reduce_op;
         let result = self.result.and_then(|mut left| {
             for right in iter {
-                left = reduce_op(left, right?)?;
+                left = reduce_op(left, right.into_result()?).into_result()?;
             }
             Ok(left)
         });

src/lib.rs

@@ -1,7 +1,6 @@
 #![doc(html_root_url = "https://docs.rs/rayon/1.0")]
 #![deny(missing_debug_implementations)]
 #![deny(missing_docs)]
-#![feature(try_trait)]
 
 //! Data-parallelism library that makes it easy to convert sequential
 //! computations into parallel