Simplify the approach

- Make the non-generic trait be the subtrait, for simplicity
- Move `BreakHolder` to future work (not required for just `?`/`try {}`)

Author: scottmcm

library/core/src/iter/adapters/peekable.rs

@@ -164,9 +164,9 @@ where
             Some(None) => try { init },
             Some(Some(v)) => match self.iter.try_rfold(init, &mut f).branch() {
                 ControlFlow::Continue(acc) => f(acc, v),
-                ControlFlow::Break(h) => {
+                ControlFlow::Break(r) => {
                     self.peeked = Some(Some(v));
-                    R::from_holder(h)
+                    R::from_residual(r)
                 }
             },
             None => self.iter.try_rfold(init, f),

library/core/src/iter/traits/iterator.rs

@@ -4,6 +4,8 @@
 
 use crate::cmp::{self, Ordering};
 use crate::ops::{self, Add, ControlFlow, Try};
+#[cfg(not(bootstrap))]
+use crate::ops::FromTryResidual;
 
 use super::super::TrustedRandomAccess;
 use super::super::{Chain, Cloned, Copied, Cycle, Enumerate, Filter, FilterMap, Fuse};
@@ -2439,30 +2441,30 @@ pub trait Iterator {
     fn try_find<F, R>(
         &mut self,
         f: F,
-    ) -> <R::Holder as ops::BreakHolder<Option<Self::Item>>>::Output
+    ) -> <R::Residual as ops::GetCorrespondingTryType<Option<Self::Item>>>::Output
     where
         Self: Sized,
         F: FnMut(&Self::Item) -> R,
         R: ops::Try<Ok = bool>,
-        R::Holder: ops::BreakHolder<Option<Self::Item>>,
+        R::Residual: ops::GetCorrespondingTryType<Option<Self::Item>>,
     {
         #[inline]
-        fn check<F, T, R>(mut f: F) -> impl FnMut((), T) -> ControlFlow<Result<T, R::Holder>>
+        fn check<F, T, R>(mut f: F) -> impl FnMut((), T) -> ControlFlow<Result<T, R::Residual>>
         where
             F: FnMut(&T) -> R,
             R: Try<Ok = bool>,
         {
             move |(), x| match f(&x).branch() {
                 ControlFlow::Continue(false) => ControlFlow::CONTINUE,
                 ControlFlow::Continue(true) => ControlFlow::Break(Ok(x)),
-                ControlFlow::Break(h) => ControlFlow::Break(Err(h)),
+                ControlFlow::Break(r) => ControlFlow::Break(Err(r)),
             }
         }
 
         match self.try_fold((), check(f)) {
-            ControlFlow::Continue(()) => ops::Bubble::continue_with(None),
-            ControlFlow::Break(Ok(x)) => ops::Bubble::continue_with(Some(x)),
-            ControlFlow::Break(Err(h)) => Try::from_holder(h),
+            ControlFlow::Continue(()) => Try::from_output(None),
+            ControlFlow::Break(Ok(x)) => Try::from_output(Some(x)),
+            ControlFlow::Break(Err(r)) => <_>::from_residual(r),
         }
     }
 

library/core/src/ops/control_flow.rs

@@ -84,16 +84,18 @@ impl<B, C> ops::Try2015 for ControlFlow<B, C> {
 }
 
 #[unstable(feature = "try_trait_v2", issue = "42327")]
-impl<B, C> ops::Bubble for ControlFlow<B, C> {
-    //type Continue = C;
+impl<B, C> ops::Try2021 for ControlFlow<B, C> {
+    //type Output = C;
     type Ok = C;
-    type Holder = ControlFlow<B, !>;
+    type Residual = ControlFlow<B, !>;
+
     #[inline]
-    fn continue_with(c: C) -> Self {
+    fn from_output(c: C) -> Self {
         ControlFlow::Continue(c)
     }
+
     #[inline]
-    fn branch(self) -> ControlFlow<Self::Holder, C> {
+    fn branch(self) -> ControlFlow<Self::Residual, C> {
         match self {
             ControlFlow::Continue(c) => ControlFlow::Continue(c),
             ControlFlow::Break(b) => ControlFlow::Break(ControlFlow::Break(b)),
@@ -102,7 +104,7 @@ impl<B, C> ops::Bubble for ControlFlow<B, C> {
 }
 
 #[unstable(feature = "try_trait_v2", issue = "42327")]
-impl<C, B> ops::BreakHolder<C> for ControlFlow<B, !> {
+impl<C, B> ops::GetCorrespondingTryType<C> for ControlFlow<B, !> {
     type Output = ControlFlow<B, C>;
     // fn expand(x: Self) -> Self::Output {
     //     match x {
@@ -112,10 +114,10 @@ impl<C, B> ops::BreakHolder<C> for ControlFlow<B, !> {
 }
 
 #[unstable(feature = "try_trait_v2", issue = "42327")]
-impl<B, C> ops::Try2021 for ControlFlow<B, C> {
-    fn from_holder(x: Self::Holder) -> Self {
+impl<B, C> ops::FromTryResidual for ControlFlow<B, C> {
+    fn from_residual(x: <Self as ops::Try2021>::Residual) -> Self {
         match x {
-            ControlFlow::Break(b) => ControlFlow::Break(b),
+            ControlFlow::Break(r) => ControlFlow::Break(r),
         }
     }
 }
@@ -222,7 +224,7 @@ impl<R: Try> ControlFlow<R, R::Ok> {
     pub fn from_try(r: R) -> Self {
         match r.branch() {
             ControlFlow::Continue(v) => ControlFlow::Continue(v),
-            ControlFlow::Break(h) => ControlFlow::Break(R::from_holder(h)),
+            ControlFlow::Break(r) => ControlFlow::Break(R::from_residual(r)),
         }
     }
 
@@ -231,7 +233,7 @@ impl<R: Try> ControlFlow<R, R::Ok> {
     #[inline]
     pub fn into_try(self) -> R {
         match self {
-            ControlFlow::Continue(v) => R::continue_with(v),
+            ControlFlow::Continue(v) => R::from_output(v),
             ControlFlow::Break(v) => v,
         }
     }

library/core/src/ops/mod.rs

@@ -185,7 +185,7 @@ pub use self::range::{Bound, RangeBounds, RangeInclusive, RangeToInclusive};
 pub use self::r#try::Try2015;
 
 #[unstable(feature = "try_trait_v2", issue = "42327")]
-pub use self::r#try::{BreakHolder, Try2021, Bubble};
+pub use self::r#try::{GetCorrespondingTryType, FromTryResidual, Try2021};
 
 #[cfg(bootstrap)]
 #[unstable(feature = "try_trait_v2", issue = "42327")]

library/core/src/ops/try.rs

@@ -73,96 +73,82 @@ pub trait Try2015 {
         all(from_method = "continue_with", from_desugaring = "QuestionMark"),
         message = "the `?` operator can only be used in {ItemContext} \
                     that returns `Result` or `Option` \
-                    (or another type that implements `{Bubble}`)",
+                    (or another type that implements `{Try2021}`)",
         label = "cannot use the `?` operator in {ItemContext} that returns `{Self}`",
         enclosing_scope = "this function should return `Result` or `Option` to accept `?`"
     ),
     on(
         all(from_method = "branch", from_desugaring = "QuestionMark"),
         message = "the `?` operator can only be applied to values \
-                    that implement `{Bubble}`",
+                    that implement `{Try2021}`",
         label = "the `?` operator cannot be applied to type `{Self}`"
     )
 )]
 #[unstable(feature = "try_trait_v2", issue = "42327")]
-pub trait Bubble {
+pub trait Try2021: FromTryResidual {
     /// The type of the value consumed or produced when not short-circuiting.
     #[unstable(feature = "try_trait_v2", issue = "42327")]
     // Temporarily using `Ok` still so I don't need to change the bounds in the library
-    //type Continue;
+    //type Output;
     type Ok;
 
     /// A type that "colours" the short-circuit value so it can stay associated
     /// with the type constructor from which it came.
     #[unstable(feature = "try_trait_v2", issue = "42327")]
-    // This could have required that we can get back here via the holder,
-    // but that means that every type needs a distinct holder.  It was removed
-    // so that the Poll impls can use Result's Holder.
-    //type Holder: BreakHolder<Self::Continue, Output = Self>;
-    type Holder: BreakHolder<Self::Ok>;
+    type Residual;
 
     /// Used in `try{}` blocks to wrap the result of the block.
     #[cfg_attr(not(bootstrap), lang = "continue_with")]
     #[unstable(feature = "try_trait_v2", issue = "42327")]
-    fn continue_with(x: Self::Ok) -> Self;
+    fn from_output(x: Self::Ok) -> Self;
 
     /// Determine whether to short-circuit (by returning `ControlFlow::Break`)
     /// or continue executing (by returning `ControlFlow::Continue`).
     #[cfg_attr(not(bootstrap), lang = "branch")]
     #[unstable(feature = "try_trait_v2", issue = "42327")]
-    fn branch(self) -> ControlFlow<Self::Holder, Self::Ok>;
+    fn branch(self) -> ControlFlow<Self::Residual, Self::Ok>;
 
     /// Demonstration that this is usable for different-return-type scenarios (like `Iterator::try_find`).
     #[unstable(feature = "try_trait_v2", issue = "42327")]
-    fn map<T>(self, f: impl FnOnce(Self::Ok) -> T) -> <Self::Holder as BreakHolder<T>>::Output
+    fn map<T>(self, f: impl FnOnce(Self::Ok) -> T) -> <Self::Residual as GetCorrespondingTryType<T>>::Output
     where
         Self: Try2021,
-        Self::Holder: BreakHolder<T>,
+        Self::Residual: GetCorrespondingTryType<T>,
     {
-        match Bubble::branch(self) {
-            ControlFlow::Continue(c) => Bubble::continue_with(f(c)),
-            //ControlFlow::Break(h) => BreakHolder::<T>::expand(h),
-            ControlFlow::Break(h) => Try2021::from_holder(h),
+        match self.branch() {
+            ControlFlow::Continue(c) => Try2021::from_output(f(c)),
+            ControlFlow::Break(r) => FromTryResidual::from_residual(r),
         }
     }
 }
 
-/// The bound on a `<T as Try>::Holder` type that allows getting back to the original.
-#[unstable(feature = "try_trait_v2", issue = "42327")]
-pub trait BreakHolder<T>: Sized {
-    /// The type from the original type constructor that also has this holder type,
-    /// but has the specified Continue type.
-    #[unstable(feature = "try_trait_v2", issue = "42327")]
-    type Output: Try2021<Ok = T, Holder = Self>;
-
-    /* Superfluous now that `FromHolder` exists
-    /// Rebuild the associated `impl Try` type from this holder.
-    #[unstable(feature = "try_trait_v2", issue = "42327")]
-    fn expand(x: Self) -> Self::Output;
-    */
-}
-
 /// Allows you to pick with other types can be converted into your `Try` type.
 ///
 /// With the default type argument, this functions as a bound for a "normal"
 /// `Try` type: one that can be split apart and put back together in either way.
 ///
 /// For more complicated scenarios you'll likely need to bound on more than just this.
 #[rustc_on_unimplemented(on(
-    all(from_method = "from_holder", from_desugaring = "QuestionMark"),
+    all(from_method = "from_residual", from_desugaring = "QuestionMark"),
     message = "the `?` operator can only be used in {ItemContext} \
                     that returns `Result` or `Option` \
-                    (or another type that implements `{Try2021}`)",
+                    (or another type that implements `{FromTryResidual}`)",
     label = "cannot use the `?` operator in {ItemContext} that returns `{Self}`",
     enclosing_scope = "this function should return `Result` or `Option` to accept `?`"
 ))]
 #[unstable(feature = "try_trait_v2", issue = "42327")]
-pub trait Try2021<T = <Self as Bubble>::Holder>: Bubble
-where
-    T: BreakHolder<Self::Ok>,
-{
-    /// Perform conversion on this holder
+pub trait FromTryResidual<Residual = <Self as Try2021>::Residual> {
+    /// Recreate the `Try` type from a related residual
     #[cfg_attr(not(bootstrap), lang = "from_holder")]
     #[unstable(feature = "try_trait_v2", issue = "42327")]
-    fn from_holder(x: T) -> Self;
+    fn from_residual(x: Residual) -> Self;
+}
+
+/// The bound on a `<T as Try>::Residual` type that allows getting back to the original.
+#[unstable(feature = "try_trait_v2", issue = "42327")]
+pub trait GetCorrespondingTryType<TryOutputType>: Sized {
+    /// The type from the original type constructor that also has this residual type,
+    /// but has the specified Output type.
+    #[unstable(feature = "try_trait_v2", issue = "42327")]
+    type Output: Try2021<Ok = TryOutputType, Residual = Self>;
 }

library/core/src/option.rs

@@ -1724,18 +1724,18 @@ impl<T> ops::Try2015 for Option<T> {
 }
 
 #[unstable(feature = "try_trait_v2", issue = "42327")]
-impl<T> ops::Bubble for Option<T> {
-    //type Continue = T;
+impl<T> ops::Try2021 for Option<T> {
+    //type Output = T;
     type Ok = T;
-    type Holder = Option<!>;
+    type Residual = Option<!>;
 
     #[inline]
-    fn continue_with(c: T) -> Self {
+    fn from_output(c: T) -> Self {
         Some(c)
     }
 
     #[inline]
-    fn branch(self) -> ControlFlow<Self::Holder, T> {
+    fn branch(self) -> ControlFlow<Self::Residual, T> {
         match self {
             Some(c) => ControlFlow::Continue(c),
             None => ControlFlow::Break(None),
@@ -1744,7 +1744,7 @@ impl<T> ops::Bubble for Option<T> {
 }
 
 #[unstable(feature = "try_trait_v2", issue = "42327")]
-impl<T> ops::BreakHolder<T> for Option<!> {
+impl<T> ops::GetCorrespondingTryType<T> for Option<!> {
     type Output = Option<T>;
 
     // fn expand(x: Self) -> Self::Output {
@@ -1755,8 +1755,8 @@ impl<T> ops::BreakHolder<T> for Option<!> {
 }
 
 #[unstable(feature = "try_trait_v2", issue = "42327")]
-impl<T> ops::Try2021<Option<!>> for Option<T> {
-    fn from_holder(x: Self::Holder) -> Self {
+impl<T> ops::FromTryResidual for Option<T> {
+    fn from_residual(x: <Self as ops::Try2021>::Residual) -> Self {
         match x {
             None => None,
         }

library/core/src/result.rs

@@ -1612,18 +1612,18 @@ impl<T, E> ops::Try2015 for Result<T, E> {
 }
 
 #[unstable(feature = "try_trait_v2", issue = "42327")]
-impl<T, E> ops::Bubble for Result<T, E> {
-    //type Continue = T;
+impl<T, E> ops::Try2021 for Result<T, E> {
+    //type Output = T;
     type Ok = T;
-    type Holder = Result<!, E>;
+    type Residual = Result<!, E>;
 
     #[inline]
-    fn continue_with(c: T) -> Self {
+    fn from_output(c: T) -> Self {
         Ok(c)
     }
 
     #[inline]
-    fn branch(self) -> ControlFlow<Self::Holder, T> {
+    fn branch(self) -> ControlFlow<Self::Residual, T> {
         match self {
             Ok(c) => ControlFlow::Continue(c),
             Err(e) => ControlFlow::Break(Err(e)),
@@ -1632,7 +1632,7 @@ impl<T, E> ops::Bubble for Result<T, E> {
 }
 
 #[unstable(feature = "try_trait_v2", issue = "42327")]
-impl<T, E> ops::BreakHolder<T> for Result<!, E> {
+impl<T, E> ops::GetCorrespondingTryType<T> for Result<!, E> {
     type Output = Result<T, E>;
 
     // fn expand(x: Self) -> Self::Output {
@@ -1643,8 +1643,8 @@ impl<T, E> ops::BreakHolder<T> for Result<!, E> {
 }
 
 #[unstable(feature = "try_trait_v2", issue = "42327")]
-impl<T, E, F: From<E>> ops::Try2021<Result<!, E>> for Result<T, F> {
-    fn from_holder(x: Result<!, E>) -> Self {
+impl<T, E, F: From<E>> ops::FromTryResidual<Result<!, E>> for Result<T, F> {
+    fn from_residual(x: Result<!, E>) -> Self {
         match x {
             Err(e) => Err(From::from(e)),
         }
@@ -1662,11 +1662,11 @@ mod sadness {
     pub struct PleaseCallTheOkOrMethodToUseQuestionMarkOnOptionsInAMethodThatReturnsResult;
 
     #[unstable(feature = "try_trait_v2", issue = "42327")]
-    impl<T, E> ops::Try2021<Option<!>> for Result<T, E>
+    impl<T, E> ops::FromTryResidual<Option<!>> for Result<T, E>
     where
         E: From<PleaseCallTheOkOrMethodToUseQuestionMarkOnOptionsInAMethodThatReturnsResult>,
     {
-        fn from_holder(x: Option<!>) -> Self {
+        fn from_residual(x: Option<!>) -> Self {
             match x {
                 None => Err(From::from(
                     PleaseCallTheOkOrMethodToUseQuestionMarkOnOptionsInAMethodThatReturnsResult,