refactored to implement without trait

Author: Xandkeeper

src/libcore/option.rs

@@ -878,6 +878,17 @@ impl<T: Default> Option<T> {
     }
 }
 
+# [unstable(feature = "inner_deref", reason = "newly added", issue = "50264")]
+impl<T: Deref> Option<T> {
+    /// Converts from `&Option<T>` to `Option<&T::Target>`.
+    ///
+    /// Leaves the original Option in-place, creating a new one with a reference
+    /// to the original one, additionally coercing the contents via `Deref`.
+    pub fn deref(&self) -> Option<&T::Target> {
+        self.as_ref().map(|t| t.deref())
+    }
+}
+
 impl<T, E> Option<Result<T, E>> {
     /// Transposes an `Option` of a `Result` into a `Result` of an `Option`.
     ///
@@ -978,24 +989,6 @@ impl<T> From<T> for Option<T> {
     }
 }
 
-#[unstable(feature = "inner_deref", reason = "newly added", issue = "50264")]
-/// Extension trait to get a reference of an Option via the Deref trait.
-pub trait OptionDeref<T: Deref> {
-    /// Converts from `&Option<T>` to `Option<&T::Target>`.
-    ///
-    /// Leaves the original Option in-place, creating a new one with a reference
-    /// to the original one, additionally coercing the contents via `Deref`.
-    fn deref(&self) -> Option<&T::Target>;
-}
-
-#[unstable(feature = "inner_deref", reason = "newly added", issue = "50264")]
-impl<T: Deref> OptionDeref<T> for Option<T>
-{
-    fn deref(&self) -> Option<&T::Target> {
-        self.as_ref().map(|t| t.deref())
-    }
-}
-
 /////////////////////////////////////////////////////////////////////////////
 // The Option Iterators
 /////////////////////////////////////////////////////////////////////////////

src/libcore/result.rs

@@ -909,6 +909,40 @@ impl<T: Default, E> Result<T, E> {
     }
 }
 
+impl<T: Deref, E: Deref> Result<T, E> {
+    #[unstable(feature = "inner_deref", reason = "newly added", issue = "50264")]
+    /// Converts from `&Result<T, E>` to `Result<&T::Target, &E>`.
+    ///
+    /// Leaves the original Result in-place, creating a new one with a reference
+    /// to the original one, additionally coercing the `Ok` arm of the Result via
+    /// `Deref`.
+    pub fn deref_ok(&self) -> Result<&T::Target, &E> {
+        self.as_ref().map(|t| t.deref())
+    }
+
+    #[unstable(feature = "inner_deref", reason = "newly added", issue = "50264")]
+    /// Converts from `&Result<T, E>` to `Result<&T, &E::Target>`.
+    ///
+    /// Leaves the original Result in-place, creating a new one with a reference
+    /// to the original one, additionally coercing the `Err` arm of the Result via
+    /// `Deref`.
+    pub fn deref_err(&self) -> Result<&T, &E::Target>
+    {
+        self.as_ref().map_err(|e| e.deref())
+    }
+
+    #[unstable(feature = "inner_deref", reason = "newly added", issue = "50264")]
+    /// Converts from `&Result<T, E>` to `Result<&T::Target, &E::Target>`.
+    ///
+    /// Leaves the original Result in-place, creating a new one with a reference
+    /// to the original one, additionally coercing both the `Ok` and `Err` arms
+    /// of the Result via `Deref`.
+    pub fn deref(&self) -> Result<&T::Target, &E::Target>
+    {
+        self.as_ref().map(|t| t.deref()).map_err(|e| e.deref())
+    }
+}
+
 impl<T, E> Result<Option<T>, E> {
     /// Transposes a `Result` of an `Option` into an `Option` of a `Result`.
     ///
@@ -999,63 +1033,6 @@ impl<'a, T, E> IntoIterator for &'a mut Result<T, E> {
     }
 }
 
-#[unstable(feature = "inner_deref", reason = "newly added", issue = "50264")]
-/// Extension trait to get a reference to a Result via the Deref trait.
-pub trait ResultDeref<T, E> {
-    /// Converts from `&Result<T, E>` to `Result<&T::Target, &E>`.
-    ///
-    /// Leaves the original Result in-place, creating a new one with a reference
-    /// to the original one, additionally coercing the `Ok` arm of the Result via
-    /// `Deref`.
-    fn deref_ok(&self) -> Result<&T::Target, &E>
-                where
-                       T: Deref;
-
-    /// Converts from `&Result<T, E>` to `Result<&T, &E::Target>`.
-    ///
-    /// Leaves the original Result in-place, creating a new one with a reference
-    /// to the original one, additionally coercing the `Err` arm of the Result via
-    /// `Deref`.
-    fn deref_err(&self) -> Result<&T, &E::Target>
-                 where
-                        E: Deref;
-
-    /// Converts from `&Result<T, E>` to `Result<&T::Target, &E::Target>`.
-    ///
-    /// Leaves the original Result in-place, creating a new one with a reference
-    /// to the original one, additionally coercing both the `Ok` and `Err` arms
-    /// of the Result via `Deref`.
-    fn deref(&self) -> Result<&T::Target, &E::Target>
-             where
-                    T: Deref,
-                    E: Deref;
-}
-
-#[unstable(feature = "inner_deref", reason = "newly added", issue = "50264")]
-impl<T, E> ResultDeref<T, E> for Result<T, E> {
-    fn deref_ok(&self) -> Result<&T::Target, &E>
-                where
-                       T: Deref,
-    {
-        self.as_ref().map(|t| t.deref())
-    }
-
-    fn deref_err(&self) -> Result<&T, &E::Target>
-                 where
-                        E: Deref,
-    {
-        self.as_ref().map_err(|e| e.deref())
-    }
-
-    fn deref(&self) -> Result<&T::Target, &E::Target>
-             where
-                    T: Deref,
-                    E: Deref,
-    {
-        self.as_ref().map(|t| t.deref()).map_err(|e| e.deref())
-    }
-}
-
 /////////////////////////////////////////////////////////////////////////////
 // The Result Iterators
 /////////////////////////////////////////////////////////////////////////////