OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Lower `?` to `Try` instead of `Carrier` 

The easy parts of RFC 1859.  (Just the trait and the lowering, none of
the error message improvements nor the insta-stable impl for Option.)
This commit is contained in:
Scott McMurray 2017-05-07 00:14:04 -07:00
parent ffb0e2dba3
commit ecde1e1d3b
7 changed files with 96 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/doc/unstable-book/src/SUMMARY.md
View File

@ -208,6 +208,7 @@
- [toowned_clone_into](library-features/toowned-clone-into.md)
- [trusted_len](library-features/trusted-len.md)
- [try_from](library-features/try-from.md)
- [try_trait](library-features/try-trait.md)
- [unicode](library-features/unicode.md)
- [unique](library-features/unique.md)
- [unsize](library-features/unsize.md)

6
src/doc/unstable-book/src/library-features/question-mark-carrier.md
View File

@ -5,3 +5,9 @@ The tracking issue for this feature is: [#31436]
[#31436]: https://github.com/rust-lang/rust/issues/31436
------------------------
This feature has been superseded by [`try_trait`][try_trait].
It exists only in stage0 for bootstrapping.
[try_trait]: library-features/try-trait.html

7
src/doc/unstable-book/src/library-features/try-trait.md Normal file
View File

@ -0,0 +1,7 @@
# `try_trait`
The tracking issue for this feature is: [#31436]
[#31436]: https://github.com/rust-lang/rust/issues/31436
------------------------

67
src/libcore/ops.rs
View File

@ -2918,15 +2918,9 @@ pub trait BoxPlace<Data: ?Sized> : Place<Data> {
fn make_place() -> Self;
}
/// A trait for types which have success and error states and are meant to work
/// with the question mark operator.
/// When the `?` operator is used with a value, whether the value is in the
/// success or error state is determined by calling `translate`.
///
/// This trait is **very** experimental, it will probably be iterated on heavily
/// before it is stabilised. Implementors should expect change. Users of `?`
/// should not rely on any implementations of `Carrier` other than `Result`,
/// i.e., you should not expect `?` to continue to work with `Option`, etc.
/// This trait has been superseded by the `Try` trait, but must remain
/// here as `?` is still lowered to it in stage0 .
#[cfg(stage0)]
#[unstable(feature = "question_mark_carrier", issue = "31436")]
pub trait Carrier {
/// The type of the value when computation succeeds.
@ -2945,6 +2939,7 @@ pub trait Carrier {
fn translate<T>(self) -> T where T: Carrier<Success=Self::Success, Error=Self::Error>;
}
#[cfg(stage0)]
#[unstable(feature = "question_mark_carrier", issue = "31436")]
impl<U, V> Carrier for Result<U, V> {
type Success = U;
@ -2970,21 +2965,57 @@ impl<U, V> Carrier for Result<U, V> {
struct _DummyErrorType;
impl Carrier for _DummyErrorType {
type Success = ();
impl Try for _DummyErrorType {
type Ok = ();
type Error = ();
fn from_success(_: ()) -> _DummyErrorType {
fn into_result(self) -> Result<Self::Ok, Self::Error> {
Ok(())
}
fn from_ok(_: ()) -> _DummyErrorType {
_DummyErrorType
}
fn from_error(_: ()) -> _DummyErrorType {
_DummyErrorType
}
fn translate<T>(self) -> T
where T: Carrier<Success=(), Error=()>
{
T::from_success(())
}
}
/// A trait for customizing the behaviour of the `?` operator.
///
/// A type implementing `Try` is one that has a canonical way to view it
/// in terms of a success/failure dichotomy. This trait allows both
/// extracting those success or failure values from an existing instance and
/// creating a new instance from a success or failure value.
#[unstable(feature = "try_trait", issue = "31436")]
pub trait Try {
/// The type of this value when viewed as successful.
#[unstable(feature = "try_trait", issue = "31436")]
type Ok;
/// The type of this value when viewed as failed.
#[unstable(feature = "try_trait", issue = "31436")]
type Error;
/// Applies the "?" operator. A return of `Ok(t)` means that the
/// execution should continue normally, and the result of `?` is the
/// value `t`. A return of `Err(e)` means that execution should branch
/// to the innermost enclosing `catch`, or return from the function.
///
/// If an `Err(e)` result is returned, the value `e` will be "wrapped"
/// in the return type of the enclosing scope (which must itself implement
/// `Try`). Specifically, the value `X::from_error(From::from(e))`
/// is returned, where `X` is the return type of the enclosing function.
#[unstable(feature = "try_trait", issue = "31436")]
fn into_result(self) -> Result<Self::Ok, Self::Error>;
/// Wrap an error value to construct the composite result. For example,
/// `Result::Err(x)` and `Result::from_error(x)` are equivalent.
#[unstable(feature = "try_trait", issue = "31436")]
fn from_error(v: Self::Error) -> Self;
/// Wrap an OK value to construct the composite result. For example,
/// `Result::Ok(x)` and `Result::from_ok(x)` are equivalent.
#[unstable(feature = "try_trait", issue = "31436")]
fn from_ok(v: Self::Ok) -> Self;
}

19
src/libcore/result.rs
View File

@ -242,6 +242,7 @@
use fmt;
use iter::{FromIterator, FusedIterator, TrustedLen};
use ops;
/// `Result` is a type that represents either success (`Ok`) or failure (`Err`).
///
@ -1108,3 +1109,21 @@ impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> {
}
}
}
#[unstable(feature = "try_trait", issue = "31436")]
impl<T,E> ops::Try for Result<T, E> {
type Ok = T;
type Error = E;
fn into_result(self) -> Self {
self
}
fn from_ok(v: T) -> Self {
Ok(v)
}
fn from_error(v: E) -> Self {
Err(v)
}
}

12
src/librustc/hir/lowering.rs
View File

@ -2244,23 +2244,23 @@ impl<'a> LoweringContext<'a> {
ExprKind::Try(ref sub_expr) => {
// to:
//
// match Carrier::translate(<expr>) {
// match Try::into_result(<expr>) {
// Ok(val) => #[allow(unreachable_code)] val,
// Err(err) => #[allow(unreachable_code)]
// // If there is an enclosing `catch {...}`
// break 'catch_target Carrier::from_error(From::from(err)),
// break 'catch_target Try::from_error(From::from(err)),
// // Otherwise
// return Carrier::from_error(From::from(err)),
// return Try::from_error(From::from(err)),
// }
let unstable_span = self.allow_internal_unstable("?", e.span);
// Carrier::translate(<expr>)
// Try::into_result(<expr>)
let discr = {
// expand <expr>
let sub_expr = self.lower_expr(sub_expr);
let path = &["ops", "Carrier", "translate"];
let path = &["ops", "Try", "into_result"];
let path = P(self.expr_std_path(unstable_span, path, ThinVec::new()));
P(self.expr_call(e.span, path, hir_vec![sub_expr]))
};
@ -2306,7 +2306,7 @@ impl<'a> LoweringContext<'a> {
self.expr_call(e.span, from, hir_vec![err_expr])
};
let from_err_expr = {
let path = &["ops", "Carrier", "from_error"];
let path = &["ops", "Try", "from_error"];
let from_err = P(self.expr_std_path(unstable_span, path,
ThinVec::new()));
P(self.expr_call(e.span, from_err, hir_vec![from_expr]))

18
src/test/run-pass/try-operator-custom.rs
View File

@ -8,20 +8,20 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![feature(question_mark, question_mark_carrier)]
#![feature(try_trait)]
use std::ops::Carrier;
use std::ops::Try;
enum MyResult<T, U> {
Awesome(T),
Terrible(U)
}
impl<U, V> Carrier for MyResult<U, V> {
type Success = U;
impl<U, V> Try for MyResult<U, V> {
type Ok = U;
type Error = V;
fn from_success(u: U) -> MyResult<U, V> {
fn from_ok(u: U) -> MyResult<U, V> {
MyResult::Awesome(u)
}
@ -29,12 +29,10 @@ impl<U, V> Carrier for MyResult<U, V> {
MyResult::Terrible(e)
}
fn translate<T>(self) -> T
where T: Carrier<Success=U, Error=V>
{
fn into_result(self) -> Result<U, V> {
match self {
MyResult::Awesome(u) => T::from_success(u),
MyResult::Terrible(e) => T::from_error(e),
MyResult::Awesome(u) => Ok(u),
MyResult::Terrible(e) => Err(e),
}
}
}