Rust: `ops :: Try`の追跡の問題（` try_trait`機能）

バイクシェディングのいくつかの部分：

• 我々は、関連するタイプを呼び出すための特定の動機を持っていますかErrorの代わりにErr ？ それを呼び出すErrそれはと整列するだろうResult ：他の一つはすでに呼び出されOk 。

• 他のinto_resultとより対称的な単一のfrom_result代わりに、別々のfrom_errorメソッドとfrom_okメソッドを持つことに特別な動機がありますか？特性の半分？

（ RFCからのプレイグラウンドリンクの更新バージョン）

@glaebhoerl

• ErrorとErrは、 https： //github.com/rust-lang/rust/issues/33417#issuecomment -269108968およびTryFromに関連して議論されました。 github.com/rust-lang/rust/pull/40281; 同様の理由でここで名前が選ばれたと思います。
• 用途が異なるため、別々であると思います。実際に誰かがT:Tryに変えようとしているResultを持っていることはめったにないと思います。 私は常にTry::from_result(Ok(とTry::from_result(Err(呼び出すよりも、 Try::from_okとTry::from_errorが好きで、一致を書き出すよりも2つのメソッドを単純化するだけで満足しています。 おそらくそれは、 into_resultをInto<Result>ではなく、「合格か不合格か」と考えているためです。特定のタイプは、重要でない実装の詳細としてResultです。 （ただし、「プロデュースバリューとアーリーリターンには新しいタイプがあるはずです」を提案したり再開したりしたくありません。）そして、ドキュメントについては、 from_errorが?について話しているのが好きです。 throw ）、 from_okは、両方を同じメソッドにするのではなく、成功ラッピング（＃41414）について説明します。

これがこのコメントの正しいフォーラムであるかどうかはわかりません。そうでない場合はリダイレクトしてください： smiley:。 おそらくこれはhttps://github.com/rust-lang/rfcs/pull/1859にあるはずで、コメント期間を逃しました。 おっとっと！

Tryトレイトを分割したり、 into_resultメソッドを削除したりする場合があるのではないかと思っていました。 私にとって現在、 Tryは、特性FromResult （ from_errorとfrom_ok ）とIntoResult （ into_resultを含む）の合計にいくらか似ています。

FromResultは、 ?演算子を使用して、人間工学に基づいた早期終了を可能にします。これは、この機能のキラーなユースケースだと思います。 IntoResultは、ユースケースごとのメソッドを使用して、またはInto<Result>としてすでに適切に実装できると思います。 私はいくつかの有用な例を見逃していますか？

Try特性RFCに従って、 expr?は次のように脱糖することができます。

match expr { // Removed `Try::into_result()` here.
    Ok(v) => v,
    Err(e) => return Try::from_error(From::from(e)),
}

私が検討した動機付けの例は、 FutureとOptionです。

未来

FromResultをstruct FutureResult: Futureように自然に実装できます。

impl<T, E> FromResult for FutureResult {
    type Ok = T;
    type Error = E;
    fn from_error(v: Self::Error) -> Self {
        future::err(v)
    }
    fn from_ok(v: Self::Ok) -> Self {
        future::ok(v)
    }
}

Result::Errに適用されたときにimpl Future値関数から返される、 ?妥当な実装を想定すると、次のように記述できます。

fn async_stuff() -> impl Future<V, E> {
    let t = fetch_t();
    t.and_then(|t_val| {
        let u: Result<U, E> = calc(t_val);
        async_2(u?)
    })
}
fn fetch_t() -> impl Future<T, E> {}
fn calc(t: T) -> Result<U,E> {}

それはまさに私が今日早く実装しようとしていたことであり、 Tryそれを釘付けにします！ しかし、現在のTryをFutureに実装しようとした場合、おそらくinto_resultの正規の選択肢はありません。 一度パニック、ブロック、またはポーリングすることは有用かもしれませんが、これらのどれも普遍的に有用ではないようです。 Tryにinto_resultがなかった場合は、上記のように早期終了を実装できます。また、 FutureをResultに変換する必要がある場合は、任意のTry ）適切なメソッドで変換できます（ブロックするにはwaitメソッドを呼び出し、 poll_once() -> Result<T,E>呼び出すなど）。

オプション

Optionも同様のケースです。 from_ok 、 from_errはTryトレイトRFCのように自然に実装され、 Option<T>をo.ok_or(Missing)簡単にResult<T, Missing>変換できます。 o.ok_or(Missing)または便利なメソッドok_or_missing 。

お役に立てば幸いです。

私はこれに非常に遅れているかもしれませんが、今週末、 ?は、_success_で短絡したい場合に、かなり自然なセマンティクスを持っていることに気づきました。

fn fun() -> SearchResult<Socks> {
    search_drawer()?;
    search_wardrobe()
}

ただし、この場合、 Try特性メソッドの名前は適合しません。

ただし、 ?演算子の意味が広がります。

レーヨンのtry_foldプロトタイプを作成する際に、 Consumer::full()メソッドにTry::is_error(&self)ようなものが必要であることに気付きました。 （消費者は基本的にプッシュスタイルのイテレータであるため、Rayonにはこれがありますが、エラーを短絡させたいのです。）代わりに中間値をResult<T::Ok, T::Err>として格納して、 Result::is_err()呼び出す必要がありました。

そこから、 Try::from_resultが最後にT戻ることも望んでいましたが、 matchはT::from_okとT::from_errorマッピングされています悪くはありません。

Tryトレイトは、 from_okとfrom_errorが必要な場合、人間工学にfrom_resultメソッドを提供できます。 またはその逆。 与えられた例から、私は両方を提供するためのケースを見る。

PR＃42275が統合されたので、この問題が解決されたことを意味しますか？

@skade LoopStateが一部のIterator内部に対して行うように、型は短絡型として定義できることに注意してください。 Tryが成功または失敗ではなく、「継続または中断」について話していれば、おそらくそれはより自然なことです。

@cuviper私が最終的に必要としたバージョンは、 OkタイプまたはError -in-originalタイプのいずれかでした。 分解と再構築が十分に一般的であり、それが適切に最適化され、特性に関する一連の特別なメソッドが必要ないことを願っています。

@ErichDonGublerこれは追跡の問題であるため、対応するコードが安定するまで解決されません。

体験レポート：

私はこの特性を実践しようとして少しイライラしました。 なんらかの理由でResultに独自のバリアントを定義したいと思うことが何度かありましたが、最終的にResultになったときは、主にTry実装したためです。 完全にはわかりません。

例：

Chalk VMの新しいソルバーでは、「ストランド」を解決した結果を示す列挙型が必要でした。 これには4つの可能性がありました。

enum StrandFail<T> {
    Success(T),
    NoSolution,
    QuantumExceeded,
    Cycle(Strand, Minimums),
}

?をこの列挙型に適用すると、「成功」をアンラップしたかったのですが、他のすべての失敗を上方に伝播しました。 ただし、 Tryトレイトを実装するには、エラーケースのみをカプセル化する一種の「残差」タイプを定義する必要がありました。

enum StrandFail {
    NoSolution,
    QuantumExceeded,
    Cycle(Strand, Minimums),
}

しかし、このタイプを取得したら、 StrandResult<T>をエイリアスにすることもできます。

type StrandResult<T> = Result<T, StrandFail>;

これが私がしたことです。

さて、これは必ずしも単一の列挙型を持つよりも悪いようには見えませんが、少し奇妙に感じます。 たとえば、関数のドキュメントを作成するときは、通常、結果を「ok」と「error」で「グループ化」するのではなく、さまざまな可能性について「等しい」と話します。 例えば：

    /// Invoked when a strand represents an **answer**. This means
    /// that the strand has no subgoals left. There are two possibilities:
    ///
    /// - the strand may represent an answer we have already found; in
    ///   that case, we can return `StrandFail::NoSolution`, as this
    ///   strand led nowhere of interest.
    /// - the strand may represent a new answer, in which case it is
    ///   added to the table and `Ok` is returned.

「 Err(StrandFail::NoSolution)を返します。これは、 Errが、追加する必要のあるこの厄介なアーティファクトのように感じられるためです。

（一方、現在の定義は、読者がTry implを?の動作が何であるかを知るのに役立ちます。）

この結果はそれほど驚くべきことではないと思います。現在のTry implは、 Result同型のものに?を使用するように強制します。 この均一性は偶然ではありませんが、その結果、基本的に「 Resultだけ」ではないもので?を使用するのは面倒です。 （さらに言えば、 NoneErrorを引き起こすのと基本的に同じ問題です。 Optionの「失敗」を表すタイプを人為的に定義する必要があります。）

また、 StrandFail場合、通常の結果で得られるFrom::from変換は特に必要ありませんが、問題はありません。

関連するTry::Errorタイプは、ユーザーに直接公開/使用されたことはありますか？ それとも、 ?脱糖の一部として必要ですか？ 後者の場合、それを「構造的に」定義するだけで実際の問題は見られません- type Error = Option<Option<(Strand, Minimums)>>など。 （ enum定義の「失敗の半分」に相当する構造を理解する必要があるのは素晴らしいことではありませんが、公開API全体を再調整する必要があるよりも煩わしくないようです。）

私もフォローしていません。 内部エラー表現を持つタイプに対してTryを正常に実装しましたが、 OkとErrorが同じタイプであるのは自然なことOk 。 ここで実装を見ることができます： https ：

実際、これを機能させるにはかなり単純なパターンがあるようです。

impl std::ops::Try for Value {
    type Ok = Self;
    type Error = Self;

    fn from_ok(v: Self::Ok) -> Self { v }
    fn from_error(v: Self::Error) -> Self { v }
    fn into_result(self) -> Result<Self::Ok, Self::Error> {
        if self.is_ok() { Ok(val) } else { Err(val) }
    }
}

成功をアンラップしたい場合は、次のようなものが機能するはずです。

impl std::ops::Try for StrandFail<T> {
    type Ok = T;
    type Error = Self;

    fn from_ok(v: Self::Ok) -> Self { StrandFail::Success(v) }
    fn from_error(v: Self::Error) -> Self { v }
    fn into_result(self) -> Result<Self::Ok, Self::Error> {
        match self {
            StrandFail::Success(v) => Ok(v),
            other => Err(other),
        }
    }
}

構造タイプを定義することは可能ですが、かなり面倒です。 Self使用できることに同意します。 ?を使用してStrandResultからResult<_, StrandResult>などに変換できるのは少し奇妙な感じがします。

素晴らしい体験レポート、@ nikomatsakis！ 私もTry （反対方向から）に不満を持っています。

TL / DR ： FoldWhileはこれを正しく理解したと思います。代わりに、 ?のBreak -vs- Continue解釈をダブルダウンする必要があります。エラーの観点から。

より長いです：

?はとても便利なので、「エラー」よりも「成功」に近いものにErrを使い続けます。

• try_foldを使用してposition （および他の多くのイテレータメソッド）Resultを使用したときと同じくらい混乱しました（私の脳はfind好きではありませんErr ）であることがわかり、代わりに列挙型を作成しました。

• itertoolsでと、内部関数が常にErr返すという奇妙なNoneがIterator::next()からの「エラー」であるというこの奇妙な切断がありますが、同時に、最後に到達する必要があるため、 foldからの「成功」です。行われなければ。 そして、終了条件の伝播を処理するために? （Rust 1.12でコンパイルする必要があるため、そのコードではtry!を使用すると非常に便利です。

したがって、他に何もないとしても、私がTryについて書いた説明は間違っていると思います。「成功/失敗の二分法」について話すのではなく、「エラー」から抽象化する必要があります。

私が考えていたもう1つのことは、 Try少しクレイジーな実装を検討する必要があるということです。 たとえば、 Ordering: Try<Ok = (), Error = GreaterOrLess>を「tryfunctions」と組み合わせると、 struct Foo<T, U> { a: T, b: U } cmpを次のようにすることができます。

fn cmp(&self, other: &self) -> Ordering try {
    self.a.cmp(&other.a)?;
    self.b.cmp(&other.b)?;
}

それがクレイジーなのか悪いのかはまだわかりません：笑い：確かにそれはある程度の優雅さを持っています、しかし、物事が異なるとあなたはそれらが異なることを知っているからです。 そして、そのいずれかの側に「成功」​​または「エラー」を割り当てようとすると、うまく適合しないようです。

また、これは「エラー変換」が役に立たないもう1つの例であることにも注意してください。 また、上記の「欲しいですか？でもエラーではありません」の例では使用していません。 そして、それは推論の悲しみを引き起こすことが確かに知られているので、それは結果だけに限定されるべきものであるかどうか疑問に思います（または.map_err(Into::into)を支持して削除される可能性がありますが、それはおそらく実行不可能です）。

編集：ああ、そしておそらく「自分のタイプにTryを実装する代わりに、エラーにResultを使用し続ける」に対する答えが「良い、それは期待されている」であるかどうか疑問に思います。

編集2：これは上記のhttps://github.com/rust-lang/rust/issues/42327#issuecomment-318923393と同じです

編集3： Continueバリアントもhttps://github.com/rust-lang/rfcs/pull/1859#issuecomment-273785250で提案されたようです

私の2セント：

特性を2つの特性に分割するという@fluffysquirrelsの提案が好きinto_resultまたは同等のものを維持する必要があると思います。 そして、 Tryが安定したので、この時点でOptionを使用する必要があると思います。

また、エラー/ OKではなくブレーク/続行を示唆する名前を使用するという@scottmcmのアイデアも気に入っています。

ここに特定のコードを入れるために、私はこれがどのように読むかが好きです：

https://github.com/rust-lang/rust/blob/ab8b961677ac5c74762dcea955aa0ff4d7fe4915/src/libcore/iter/iterator.rs#L1738 -L1746

もちろん、ストレートループほど良くはありませんが、「tryメソッド」を使用すると、次のようになります。

self.try_for_each(move |x| try { 
    if predicate(&x) { return LoopState::Break(x) } 
}).break_value() 

比較のために、「エラー語彙」バージョンは本当に誤解を招くと思います。

self.try_for_each(move |x| { 
    if predicate(&x) { Err(x) } 
    else { Ok(()) } 
}).err() 

NoneErrorの表示を実装できますか？ これにより、障害クレートが自動的にFrom<NoneError> for failure::Error導出できるようになります。 https://github.com/rust-lang-nursery/failure/issues/61を参照して
3行の変更になるはずですが、RFCなどのプロセスについてはよくわかりません。

@ cowang4タイプは不安定で、オプションを開いたままにしておくため、今は結果とオプションの混合を有効にしないようにしたいと思います。 Tryのデザインと脱糖剤を、 NoneError必要としないものに変更したとしても驚かないでしょう...

@scottmcmわかりました。 あなたの言ってる事がわかります。 最終的には、ライブラリ関数がNoneを返したときにErrを返すパターンをシュガーするクリーンな方法が必要です。 たぶんあなたはTry以外のものを知っていますか？ 例：

fn work_with_optional_types(pb: &PathBuf) -> Result<MyStruct, Error> {
    if let Some(filestem) = pb.file_stem() {
        if let Some(filestr) = filestem.to_str() {
            return Ok(MyStruct {
                filename: filestr.to_string()
            });
        }
     }
    Err(_)
}

この実験的な機能とfailureクレートを見つけたら、私は自然に次のことに惹かれました。

use failure::Error;
fn work_with_optional_types(pb: &PathBuf) -> Result<MyStruct, Error> {
    Ok({
        title: pb.file_stem?.to_str()?.to_string()
    })
}

前に述べたようにimpl Display for NoneErrorがないことを除いて、どちらが_ほぼ_機能します。
しかし、これが私たちが使用したい構文でない場合は、パターンを単純化する別の関数/マクロがある可能性があります。

if option.is_none() {
    return Err(_);
}

@ cowang4 Displayを実装した独自のタイプを使用したfailure::Errorに対してFrom<NoneError>を実装した場合、これは機能すると思います。

ただし、OptionがNoneの場合のエラーを明示的に指定できるように、 opt.ok_or(_)?使用することをお勧めします。 たとえば、あなたの例では、 pb.file_stemがNoneの場合と、 to_str()がNoneを返す場合とで異なるエラーが必要になる場合があります。

@tmccombs独自のエラータイプを作成しようとしましたが、間違って作成したに違いありません。 それはこのようなものでした：

#[macro_use] extern crate failure_derive;

#[derive(Fail, Debug)]
#[fail(display = "An error occurred.")]
struct SiteError;

impl From<std::option::NoneError> for SiteError {
    fn from(_err: std::option::NoneError) -> Self {
        SiteError
    }
}

fn build_piece(cur_dir: &PathBuf, piece: &PathBuf) -> Result<Piece, SiteError> {
    let title: String = piece
        .file_stem()?
        .to_str()?
        .to_string();
    Ok(Piece {
        title: title,
        url: piece
            .strip_prefix(cur_dir)?
            .to_str()
            .ok_or(err_msg("tostr"))?
            .to_string(),
    })
}

そして、エラータイプを使用してみました...

error[E0277]: the trait bound `SiteError: std::convert::From<std::path::StripPrefixError>` is not satisfied
   --> src/main.rs:195:14
    |
195 |           url: piece
    |  ______________^
196 | |             .strip_prefix(cur_dir)?
    | |___________________________________^ the trait `std::convert::From<std::path::StripPrefixError>` is not implemented for `SiteError`
    |
    = help: the following implementations were found:
              <SiteError as std::convert::From<std::option::NoneError>>
    = note: required by `std::convert::From::from`

error[E0277]: the trait bound `SiteError: std::convert::From<failure::Error>` is not satisfied
   --> src/main.rs:195:14
    |
195 |           url: piece
    |  ______________^
196 | |             .strip_prefix(cur_dir)?
197 | |             .to_str()
198 | |             .ok_or(err_msg("tostr"))?
    | |_____________________________________^ the trait `std::convert::From<failure::Error>` is not implemented for `SiteError`
    |
    = help: the following implementations were found:
              <SiteError as std::convert::From<std::option::NoneError>>
    = note: required by `std::convert::From::from`

さて、私は、他のエラータイプから自分のエラーに変換する方法を知りたいと思っていることに気づきました。これは一般的に書くことができます。

impl<E: failure::Fail> From<E> for SiteError {
    fn from(_err: E) -> Self {
        SiteError
    }
}

いいえ...

error[E0119]: conflicting implementations of trait `std::convert::From<SiteError>` for type `SiteError`:
   --> src/main.rs:183:1
    |
183 | impl<E: failure::Fail> From<E> for SiteError {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: conflicting implementation in crate `core`:
            - impl<T> std::convert::From<T> for T;

さて、 std::error::Errorどうですか？

impl<E: std::error::Error> From<E> for SiteError {
    fn from(_err: E) -> Self {
        SiteError
    }
}

それもうまくいきません。 私のFrom<NoneError>と競合することもあります

error[E0119]: conflicting implementations of trait `std::convert::From<std::option::NoneError>` for type `SiteError`:
   --> src/main.rs:181:1
    |
175 | impl From<std::option::NoneError> for SiteError {
    | ----------------------------------------------- first implementation here
...
181 | impl<E: std::error::Error> From<E> for SiteError {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `SiteError`
    |
    = note: upstream crates may add new impl of trait `std::error::Error` for type `std::option::NoneError` in future versions

NoneErrorはstd::error::Error実装していないと思ったので、これは奇妙です。 非ジェネリックimpl From<NoneError>をコメントアウトすると、次のようになります。

error[E0277]: the trait bound `std::option::NoneError: std::error::Error` is not satisfied
   --> src/main.rs:189:25
    |
189 |       let title: String = piece
    |  _________________________^
190 | |         .file_stem()?
    | |_____________________^ the trait `std::error::Error` is not implemented for `std::option::NoneError`
    |
    = note: required because of the requirements on the impl of `std::convert::From<std::option::NoneError>` for `SiteError`
    = note: required by `std::convert::From::from`

すべてのFrom手動で書き込む必要がありますか？ 私は失敗の箱がそれらを導き出すことになっていたと思いましたか？

多分私はoption.ok_or()固執する必要があります

すべてのFromを手動で書き込む必要がありますか？ 私は失敗の箱がそれらを導き出すことになっていたと思いましたか？

失敗箱がそうすることはないと思います。 しかし、私は間違っている可能性があります。

さて、私は失敗クレートを再検討しました。ドキュメントとさまざまなバージョンを正しく読んでいる場合は、 Resultのエラータイプとして常にfailure::Errorを使用するように設計されています。ここを参照してください。 また、ほとんどのエラータイプに対して包括的なimpl Fail特性を実装しています。

impl<E: StdError + Send + Sync + 'static> Fail for E {}

https://github.com/rust-lang-nursery/failure/blob/master/failure-1.X/src/lib.rs#L218

次に、 impl From使用して、他のエラー（stdからのエラーなど）を包括的なfailure::ErrorタイプにTry / ?できるようにします。
rust impl<F: Fail> From<F> for ErrorImpl
https://github.com/rust-lang-nursery/failure/blob/d60e750fa0165e9c5779454f47a6ce5b3aa426a3/failure-1.X/src/error/error_impl.rs#L16

ただし、この錆の問題に関連するエラーNoneErrorは実験的なものであるため、 Display特性が実装されていないため、まだ自動的に変換できません。 そして、それはOptionとResultの間の境界線をさらに曖昧にするので、私たちはそれを望んでいません。 それはおそらくすべて再加工され、最終的には整理されるでしょうが、今のところ、私は私が学んだ脱糖技術に固執します。

助けてくれてありがとう。 私はゆっくりとRustを学んでいます！ ：笑顔：

私は私が学んだ脱糖技術に固執します。

：+1：正直なところ、 .ok_or(...)?は今後も続くと思います（もちろん、 .ok_or_else(|| ...)? ）。 NoneErrorがDisplay implを持っていた

具体的な提案に近づこうとしています...

私はTrySuccess代替品が好きになり始めています。 興味深いことに、私も含めて_nobody_は、もともとそれが好きだったと思います。RFCの最終バージョンにも含まれていません。 しかしありがたいことに、それは歴史の中で生き続けています： //github.com/rust-lang/rfcs/blob/f89568b1fe5db4d01c4668e0d334d4a5abb023d8/text/0000-try-trait.md#using -an-associated-type-for-the-success -価値

それに対する最大の異議は、関連する型（ trait TrySuccess { type Success; } ）だけのコア特性全体がやり過ぎだったという合理的な不満だったように私には感じます。 しかし、 catch tryブロックを使用して（https://github.com/rust-lang/rust/issues/41414#issuecomment-373985777）ok-wrappingを実行します（RFCのように） 、突然、直接かつ重要な用途があります。これは、そのラッピングを制御する特性です。 「 ?は常に同じタイプを生成する必要がある」という目標と相まって、一般的に望まれていると思いますが、この特性はその重みをよりよく保持しているようです。 わら人形：

trait TryContinue {
    type Continue;
    fn from_continue(_: Self::Continue) -> Self;
}

?演算子から返されるものとして、その関連付けられた型は、明らかに存在する必要がある型でもあります。 つまり、ニコが明確に述べた「一種の「残余」タイプを定義する必要があった」という煩わしさにはぶつからないということです。 そして、それが()は合理的であり、一般的でさえあるので、 NoneErrorようなゆがみを避けます。

編集：バイクシェッドの場合、「return」は良い言葉かもしれません。これは、 tryメソッド（別名ok-wrapping）からreturnしたときに発生するためです。 returnは、このiiucのモナド演算子名でもあります。

編集2：他の特性/方法に関する私の考えはまだ安定していません、@ tmccombs。

@scottmcm明確にするために、または次の2つの特性を提案しますか？

trait TryContinue {
  type Continue;
  fn from_continue(_: Self::Continue) -> Self;
}

trait Try<E>: TryContinue {
  fn try(self) -> Result<Self::Continue, E>
}

そして、 x?を非難すると、次のようになります。

x.try() match {
    Ok(c) => c,
   Err(e) => throw e // throw here is just a placeholder for either returning or breaking out of a try block
}

そしてtry { ...; expr}は次のようなものに脱糖します：

{ 
    ...
    TryContinue::from_continue(expr);
}

@scottmcm ok-wrapping =）を検討すると、私もそのバリアントの方がはるかに魅力的だと思います。

次の特性に進むと、 ?特性は次のようになると思います（モジュロ大規模なバイクシェディング）：

trait Try<Other: TryContinue = Self>: TryContinue + Sized {
    fn check(x: Other) -> ControlFlow<Other::Continue, Self>;
}

enum ControlFlow<C, B> {
    Continue(C),
    Break(B),
}

さまざまな正当化：

• x?式の型が常に同じになるように、引数の型にTryContinueが必要です。
• これは、同じタイプを検査して返すtry_foldような単純なケースでは、typeパラメーターをデフォルトでSelfに設定するため、 T: Tryだけで問題ありません。
• この特性はTryContinue拡張します。これは、戻り型として使用される型が本体で?を許可する場合、ok-wrappingもサポートする必要があるためです。
• 新しい列挙型は結果として同型ですが、前述のように「エラー」の観点から話すことを避け、その結果、各バリアントに非常に明確な意味を提供すると思います。
• ?の引数は汎用型であるため、 TryContinue 、「何かからSelfを生成する」ようになります。

try{} / ?マクロと、 Option 、 Result 、およびOrdering実装を含む完全な概念実証デモ： https ：//play.rust-lang.org/？gist = 18663b73b6f35870d20fd172643a4f96＆version = stable （ 1年前にてくれた@nikomatsakisに感謝し

欠点：

• Result implにファントムタイプのパラメーターがまだありますが、私はあまり好きではありません
  
  
  
  • しかし、おそらくそれは、 Ordering implに追加のLessOrGreaterタイプを必要としないための良いトレードオフです。
  
  
  • そして、implsのファントムタイプパラメータは、とにかくタイプよりも厄介ではありません
  
  
• 一貫したFrom変換を提供しません
  
  
  
  • しかし、 StrandResultはとにかく気にしなかったので、それは良いかもしれません。 SearchResultようなものでは、ブレークパスが成功パスであるため奇妙であり、推論に役立つ可能性があります。とにかくネストされた?ケース。
  
  
• throw構文がどうなるかはそれほど明白ではありません
  
  
  
  • これは私が本当に好きだったOk(x) => x, Err(r) => throw e.into()としての?の説明を失います
  
  
  • しかし、 throw; （ impl<T> Throw<()> for Option<T>ようなものを介して） Noneを生成する方法にすることもできます。これは、 throw NoneError;よりもはるかに優れています。
  
  
  • そして、それを分離することはとにかく良いかもしれません。なぜなら、 throw LessOrGreater::Lessは_本当に_ばかげているからです。
  
  

編集：Ping @ glaebhoerl 、 望んでいる意見。

編集2： https ： ください。

本質主義的アプローチは、上記の目標を犠牲にすることなく、還元主義者の優雅さの一部を採用できるのだろうか。

私はその提案が本当に好きです。

スロー構文が何であるかはそれほど明白ではありません

他の言語からのthrowキーワードの手荷物を無視すると、「throw」は、より高いスコープまで値を「スロー」するという点で、ある意味で意味があります。 Pythonとscalaは、エラーの場合以外に制御フローの例外も使用します（ただし、scalaの場合、通常は直接try / catchを使用しません）。そのため、成功したパスにthrowを使用する前例がいくつかあります。

@tmccombs

他の言語からのthrowキーワードの手荷物を無視すると、「throw」は、より高いスコープまで値を「スロー」するという点で、ある意味で意味があります。

同様の手荷物が付属していますが、「レイズ」の方が適していると思います。

投げる（v）：投げつけるように、ある場所、位置、状態などに入れたり、入れたり、入れたりすること：

上げる（v）：より高い位置に移動します。 持ち上げる; 昇格

「raise」を?のロジックと組み合わせる方法があるかもしれません。これは、raiseが「collect」を意味する場合もあるためです。 Ok(v) => v, Err(e) => raise From::from(e)になります。ここで、 raiseは一致したパターンを模倣します（たとえば、パターンErr(e)与えられると、 ControlFlow::Break(Err(...))構文上の魔法になります）。

「レイズ」の方が適していると思います

いい視点ね

@scottmcm

スロー構文が何であるかはそれほど明白ではありません

from_err(value: Other)を持てない理由はありますか？

更新：実際、 Otherの役割について混乱しているかもしれません。 私はこの特性をもう少し研究する必要があります。 =）

@nikomatsakis

from_err(value: Other)を持てない理由はありますか？

ええと、 Otherは完全に?なタイプ（ Resultような）なので、 throw Ok(4)を機能させたくありません。 （そして、人為的なエラータイプの導入を強制することを避けるために、完全な論理和である必要があります。）たとえば、現在のOption-Result相互運用はこれ（およびその逆）と同等であると思います。

impl<T, F, U> Try<Option<U>> for Result<T, F>
   where F: From<NoneError>
{
    fn check(x: Option<U>) -> ControlFlow<U, Self> {
        match x {
            Some(x) => ControlFlow::Continue(x),
            None => ControlFlow::Break(Err(From::from(NoneError))),
        }
    }
}

throwに対する私の現在の傾向は、次のとおりです。

trait TryBreak<T> : TryContinue { from_break(_: T) -> Self }

と

throw $expr  ==>  break 'closest_catch TryBreak::from_break($expr)

• TryContinueを拡張して、使用されているメソッドの戻り型に対してok-wrappingも使用できるようにします。
• 関連付けられたタイプではないため、必要に応じて、タイプにTryBreak<TryFromIntError>とTryBreak<io::Error>両方を実装できます。
  
  
  
  • throw;だけを有効にするimpl<T> TryBreak<()> for Option<T>は、関連するエラータイプ()がそうではなかった方法でもっともらしいと感じます。
  
  
  • impl<T> TryBreak<!> for Tもいいでしょうが、おそらく一貫性がありません。
  
  

（余談ですが、これらの特性とメソッド名はひどいです。助けてください！）

ここで提起された他の問題についての私の考えは、まだ明確に表現できる形にはなりませんが、 From::from()脱糖に関する型推論の問題に関して（これが最近どこかで議論されたかどうかは思い出せません） 、またはここだけ？）：

「そのように型推論のあいまいさがある」という本能的な感覚（主なものではありませんが）は、元のRFCの一部としてFrom変換を望まなかった理由の

つまり、 From::from() [オプション：手動で記述されるのではなく、 ?脱糖によって挿入されたもの]が表示され、2つのタイプのどちらかを正確に知っていると思います（入力対出力）、もう一方はあいまいですが、デフォルトではもう一方は1つと同じになります。 つまり、どのimpl Fromを使用するかが明確でない場合、デフォルトでimpl<T> From<T> for T設定されると思います。 これは、基本的に常にあなたが実際に欲しいものだと思いますか？ それは少しアドホックかもしれませんが、それが機能する場合、メリットは私見のコストに見合うだけの価値があるようです。

（ Fromは、正確には?脱糖のために、すでにlangアイテムだと思いましたが、そうではないようです？いずれにせよ、その理由ですでにいくつかの点で特別です。 。）

@scottmcmの提案では、 From::from()は脱糖の一部ではなく、 ResultのTryの実装に含まれています。

@tmccombs私は彼の提案の修正を提案していませんでした。

try{} RFC（https://github.com/rust-lang/rfcs/pull/2388）は、結果を気にしないtryブロックについて議論してきました。 この代替手段は、必要に応じてエラータイプを完全に無視することを選択できるため、これを適切に処理できるようです。

let IgnoreErrors = try {
    error()?;
    none()?;
};

以前と同じ特性を使用した概念実証の実装： https ： stable

特に、カスタム実装では結果を取得してE: Debugをバインドするだけで、発生したエラーを自動的にログに記録できるため、興味深い可能性がいくつかあると思います。 または、 mainとTerminationリターン型として特別に意図されたバージョンを作成して、複雑な型の署名なしで?を使用できるようにすることもできます（https ：//github.com/rust-lang/rfcs/issues/2367）。

@nikomatsakisが既存のバージョンのTryトレイトを使用して証明したものと同様の問題が発生しました。 特定の問題については、 https： //github.com/SergioBenitez/Rocket/issues/597#issuecomment-381533108を参照して

@scottmcmによって提案された特性定義は、これらの問題を解決します。 ただし、必要以上に複雑なようです。 私はそれらを再実装することにひびを入れて、次のことを思いついた：

#[derive(Debug, Copy, Clone)]
enum ControlFlow<C, B> {
    Continue(C),
    Break(B),
}

// Used by `try { }` expansions.
trait FromTry: Try {
    fn from_try(value: Self::Continue) -> Self;
}

// Used by `?`.
trait Try<T = Self>: Sized {
    type Continue;
    fn check(x: T) -> ControlFlow<Self::Continue, Self>;
}

主な変更点は、 Continue関連付けられたタイプが、 FromTry （以前のTryContinue ）ではなくTryトレイトにあることです。 定義を単純化するだけでなく、これはという利点があるTryとは独立して実装することができますFromTry私はより一般的であると断定され、そしてそれは実装FromTry簡略化されているが、一度Tryが実装されています。 （注： TryとFromTry同時に実装する必要がある場合は、 from_tryメソッドをTry移動するだけです）

ResultとOption実装を含む完全な遊び場と、この遊び場でのRocketのOutcomeをご覧ください。

報告してくれてありがとう、@ SergioBenitez！ その実装は、RFC 1859の元の特性提案の「タイプパラメータを反転する」代替バージョンと一致します： https ：

失う最大のことは、 typeof(x?)がtypeof(x)のみに依存するという特性です。 そのプロパティの欠如は、オリジナルの懸念事項の1つであり（「これらの行に沿ったコードの読みやすさについて少し心配しています」https://github.com/rust-lang/rfcs/pull/1859#issuecomment-279187967）、利点があります。最終的な削減主義者の提案の（「任意のタイプTに対して、？は正確に1種類のok / error値を生成できます」https://github.com/rust-lang/rfcs/pull/1859#issuecomment-283104310）。 もちろん、プロパティが不要または制限が多すぎるという議論もありましたが、FCPの前の最終的な要約では、それはまだ利点としてありました（https://github.com/rust-lang/rfcs/pull/1859#issuecomment -295878466）。

定義を単純化することに加えて、これには、 TryをFromTryとは独立して実装できるという利点があります。これは、私がより一般的であると考えています。

確かに今日、 Tryとdo catchは不安定であるため、 from_okはあまり一般的ではありません。 また、 do catchが安定していても、全体で?未満で使用されることに同意します（このようなブロックのほとんどには複数の?が含まれているため）。

ただし、特性とその操作の観点から、「キャリアタイプで「継続」値をラップする」ことは?絶対に不可欠な部分だと思います。 今日、その特性を通過することはめったにありません-代わりにOk(...)またはSome(...)使用するだけです-しかし、それは一般的な使用法にとって重要です。 たとえば、 try_fold ：

https://github.com/rust-lang/rust/blob/8728c7a726f3e8854f5a80b474d1a8bacab10304/src/libcore/iter/iterator.rs#L1478 -L1482

関数がキャリアタイプを返す場合は、対象の値をそのキャリアタイプに入れる方法があることが重要です。 そして、重要なことに、これを提供することは困難ではないと思います。 結果、オプション、結果などの非常に自然な定義があります。

@Centrilはまた、「スカラーをキャリアにラップする」も理論的にはより単純な構成であることを以前に指摘しました。 たとえば、HaskellはそれをPointedクラスと呼んでいますが、Rustでは一般化したくないと思います。 try { 4 }許可する↦ vec![4]は私にはやり過ぎのようです。

また、ブロック値を未来にラップするためにasync関数が提案されているように、ブロック値をフォールブルタイプにラップするtry関数があるかもしれない未来を想像しています。 ここでも、 TryContinueが重要な部分です。 throw構造を取得した場合、このような関数は?使用しない可能性があります。

つまり、残念ながら、それは具体的なものよりも哲学的なものです。 それが意味をなすかどうか、またはあなたがいずれかの部分で反対だと思うかどうか私に知らせてください：slightly_smiling_face：

編集：これの初期バージョンが記載されたメールを受け取った場合はお詫びします。 「コメント」を押すのが早すぎた...

失われる最大のことは、typeof（x？）がtypeof（x）のみに依存するという特性です。

ああ、絶対に。 それを指摘してくれてありがとう。

もちろん、プロパティが不要または制限が多すぎるという議論もありましたが、FCPの前の最終的な要約では、それはまだ利点としてありました（rust-lang / rfcs＃1859（コメント））。

制限が厳しすぎる可能性のある具体的な例はありますか？

関数がキャリアタイプを返す場合は、対象の値をそのキャリアタイプに入れる方法があることが重要です。 そして、重要なことに、これを提供することは困難ではないと思います。

それは公正な分析だと思います。 同意します。

@SergioBenitezhttps ： //github.com/rust-lang/rfcs/pull/1859#issuecommentから-279187967

だから問題は、提案された制限は十分ですか？ 成功タイプを決定する際にエラーケースコンテキストの適切な使用法はありますか？ 虐待の可能性はありますか？

将来の私の経験から、ここにはいくつかの有用なケースがあるかもしれないと言うことができます。 特に、あなたが話している投票タイプは、いくつかの方法で処理できます。 NotReadyバリアントに飛び出して、本質的にResult値を残したい場合があります。 場合によっては、Readyバリアントのみに関心があり、他のバリアントのいずれかに飛び出したいことがあります（スケッチのように）。 成功タイプをエラータイプによって部分的に決定できるようにすると、これらの両方のケースをサポートすることがより妥当であり、基本的にコンテキストを使用して、必要な分解の種類を決定します。

OTOH、私はこれらの行に沿ったコードの読みやすさについて少し心配しています。 これは、単にエラーコンポーネントを変換することとは質的に異なるように感じます。つまり、基本的に一致するということですか？ 実行されるかどうかは、コンテキスト情報に依存します。

したがって、_両方_の型を型パラメータに移動する特性を想像することができます。

trait Try<T,E> {
    fn question(self) -> Either<T, E>;
}

そしてそれを使用すると、すべてが有効になります

let x: Result<_,_> = blah.poll()?; // early-return if NotReady
let x: Async<_> = blah.poll()?; // early-return if Error
let x: i32 = blah.poll()?; // early-return both NotReady and Errors

しかし、それはこれらが機能しないことを意味するので、それは間違いなく悪い考えだと思います

println!("{}", z?);
z?.method();

何を生成するかを言うタイプコンテキストがないので。

他のバージョンは、次のようなことを有効にすることです。

fn foo() -> Result<(), Error> {
    // `x` is an Async<i32> because NotReady doesn't fit in Result
    let x = something_that_returns_poll()?;
}
fn bar() -> Poll<(), Error> {
    // `x` is just i32 because we're in a Poll-returning method
    let x = something_that_returns_poll()?;
}

私の本能は、推論が「？から流れ出る」ということです。 意外すぎるので、これは「賢すぎる」バケツにあります。

批判的に、私はそれを持たないことはあまり制限的ではないと思います。 my_result? -> Poll関数のmy_result?は、成功タイプが通常と同じであり（同期コードが非同期コンテキストで同じように機能し続けるために重要）、エラーバリアントも正常に変換されるため、これは必要ありません。 。 Resultを返すメソッドのPollで?を使用することは、とにかくアンチパターンのように見えますが、一般的なものではないため、 .wait(): Tような（仮想の）専用メソッドを使用します。とにかく、モードを選択するための.ready(): Option<T> （完了したかどうかを確認するため）の方がおそらく良いでしょう。

これは「興味深い」 https://play.rust-lang.org/?gist=d3f2cd403981a631f30eba2c3166c1f4&version=nightly&mode=debug

私はこれらのtry（do catch）ブロックが好きではありません、彼らはあまり新参者に優しいようには見えません。

複数のコメントにまたがっているように見える提案の現在の状態をまとめようとしています。 現在提案されている一連の特性（ Error関連タイプを削除する）の単一の要約はありますか？

このスレッドの早い段階で、 Tryをエラー特性とは別の特性に分割することについてのコメントがあります-その分割を実装する計画はありますか？

疑問符でResult<T, E>から任意のタイプOther<T2, E>への透過的な変換があると便利です。これにより、既存のIO関数を、より特殊な関数内から適切な構文で呼び出すことができます（例：怠惰な）戻り型。

pub fn async_handler() -> AsyncResult<()> {
    let mut file = File::create("foo.txt")?;
    AsyncResult::lazy(move || {
        file.write_all(b"Hello, world!")?;
        AsyncResult::Ok(())
    })
}

意味的にはこれはFrom::from(E) -> Other<T2, E>ように感じますが、 Fromは現在、既存のResult同等のTry実装に制限されています。

NoneErrorは別の追跡の問題があるはずだと本当に思います。 場合でも、 Try特性、安定化れることは決してありませんNoneErrorそれが使用しますので、安定するまで必要があります?にOptionはるかに人間工学に基づきました。 struct MyCustomSemanthicalError;ようなエラー、またはDefault実装するエラーについては、これを考慮してください。 Noneは、 From<NoneError>介して簡単にMyCustomSeemanthicalError変換できます。

https://github.com/rust-analyzer/rust-analyzer/で作業しているときに、特にリターンタイプがResult<Option<T>, E>場合、 ?演算子の不足とは少し異なるペーパーカットに遭遇しました。 Result<Option<T>, E> 。

このタイプの場合、 ?が効果的に次のように脱糖することは理にかなっています。

match value? {
    None => return Ok(None),
    Some(it)=>it,
}

ここで、 valueはタイプResult<Option<V>, E>であるか、または：

value?

ここで、 valueはResult<V, E>です。 これは、標準ライブラリがOption<T>に対して次のようにTryを実装している場合に可能であると思いますが、これを明示的にテストしておらず、特殊化の問題があると思います。

enum NoneError<E> {
    None,
    Err(E),
}

impl From<T> for NoneError<T> {
    fn from(v: T) -> NoneError<T> {
        NoneError:Err(v)
    }
}

impl<T, E> std::Ops::Try for Result<Option<T>, E> {
    type OK = T;
    type Error = NoneError<E>;
    fn into_result(self) -> Result<Self::OK, Self::Error> {
        match self {
            Ok(option) => {
                if let Some(inner) = option {
                    Ok(inner)
                } else {
                    Err(NoneError::None)
                }
            }
            Err(error) => {
                Err(NoneError::Err(error));
            }
        }
    }
    fn from_error(v: Self::Error) -> Self {
        match v {
            NoneError::Err(error) => Err(error),
            None => Some(None),
        }
    }
    fn from_ok(v: Self::OK) -> Self {
        Ok(Some(v))
    }
}

impl<T> std::Ops::Try for Option<T> {
    type OK = T;
    type Error = NoneError<!>;
    fn into_result(self) -> Result<Self::OK, Self::Error> {
        match self {
            None => Err(NoneError::None),
            Some(v) => Ok(v),
        }
    }
    fn from_error(v: Self::Error) -> Self {
        match v {
            NoneError::None => Some(None),
            _ => unreachable!("Value of type ! obtained"),
        }
    }
    fn from_ok(v: Self::OK) -> Self {
        Ok(v)
    }
}

これについてコメントしたかったので、 https： //github.com/rust-lang/rust/issues/31436#issuecomment -441408288から再投稿しましたが、それは間違った問題だったと思います。

基本的に、私が持っている状況はGUIフレームワークでのコールバックです- OptionまたはResultを返す代わりに、 UpdateScreenを返す必要があります。更新する必要があるかどうか。 多くの場合、ログを記録する必要はまったくなく（すべてのマイナーエラーにログオンするのは実際的ではありません）、エラーが発生したときにUpdateScreen::DontRedraw返すだけです。 ただし、現在の?演算子では、これを常に記述する必要があります。

let thing = match fs::read(path) {
    Ok(o) => o,
    Err(_) => return UpdateScreen::DontRedraw,
};

Try演算子を使用してResult::ErrからUpdateScreen::DontRedraw変換できないため、これは非常に面倒になります。ハッシュマップで単純なルックアップが失敗することがよくあります（これはエラーではありません）。 ）-1回のコールバックで?演算子を5〜10回使用することがよくあります。 上記の書き込みに非常に冗長なので、私の現在のソリューションは、にあるimpl From<Result<T>> for UpdateScreenこのようにして、このようなコールバックで内部関数を使用します。

fn callback(data: &mut State) -> UpdateScreen {
     fn callback_inner(data: &mut State) -> Option<()> {
         let file_contents = fs::read_to_string(data.path).ok()?;
         data.loaded_file = Some(file_contents);
         Some(())
     }

    callback_inner(data).into()
}

コールバックは関数ポインターとして使用されるため、 -> impl Into<UpdateScreen>使用できません（何らかの理由で、 impl返すことは現在関数ポインターでは許可されていません）。 したがって、 Try演算子を使用する唯一の方法は、内部関数のトリックを実行することです。 私が単にこのようなことをすることができればそれは素晴らしいでしょう：

impl<T> Try<Result<T>> for UpdateScreen {
    fn try(original: Result<T>) -> Try<T, UpdateScreen> {
        match original {
             Ok(o) => Try::DontReturn(o),
             Err(_) => Try::Return(UpdateScreen::DontRedraw),
        }
    }
}

fn callback(data: &mut State) -> UpdateScreen {
     // On any Result::Err, convert to an UpdateScreeen::DontRedraw and return
     let file_contents = fs::read_to_string(data.path)?;
     data.loaded_file = Some(file_contents);
     UpdateScreen::Redraw
}

現在の提案でこれが可能かどうかはわかりませんが、検討のためにユースケースを追加したかっただけです。 カスタムのTry演算子がこのようなものをサポートできれば素晴らしいと思います。

@joshtriplettこれに戻るのに時間がかかってすみません。 具体的には、 https ：

@scottmcm変更についてのより高いレベルの説明がありますか？

@scottmcm FWIWレーヨンの変更も試してみました：
https://github.com/rayon-rs/rayon/compare/master...cuviper：try-trait-v2
（不安定なアイテムではなく、まだプライベートコピーを使用しています）

では、Option NoneErrorを変換するための解決策は何ですか？ Try Traitを実装しているため、その特定の（不安定な？）機能の使用を有効にしない限りコンパイルされないようです。

だから基本的には使えないの？ 私の知る限り、オプション付きの演算子？

@omarabid 、演算子はOptionまたはResultでの使用Try安定していますが、安定するまでジェネリック制約としてNoneErrorをまったく関与させる必要がないため、 Option返す関数のOptionで?を使用することはまったく問題ありません。 タイプを消去すると、 Result返すこともできます。

use std::fmt::Debug;

pub struct Error(Box<dyn Debug>);

impl<T: Debug + 'static> From<T> for Error {
    fn from(error: T) -> Self {
        Error(Box::new(error))
    }
}

pub fn try_get<T>(slice: &[T], index: usize) -> Result<&T, Error> {
    Ok(slice.get(index)?)
}

（遊び場）

@scottmcm 、プロトタイプtry-trait-v2はこの例に失敗します！

私の例を壊したくない場合、 try-trait-v2は次のようなものが必要になります。

#[unstable(feature = "try_trait_v2", issue = "42327")]
impl<T, U, E: From<NoneError>> ops::Bubble<Result<U, E>> for Option<T> {
    fn bubble(self) -> ops::ControlFlow<T, Result<U, E>> {
        match self {
            Some(x) => ops::ControlFlow::Continue(x),
            None => ops::ControlFlow::Break(Err(E::from(NoneError))),
        }
    }
}

この機能の現在のステータスは何ですか？

イテレータのtry_fold実装を文書化するPR＃62606は、これが安定したら再度開く必要があります。

編集：そのための追跡アイテムでopを更新しました〜scottmcm

Try特性をこのスレッドで提案されている代替案のいずれかに置き換える計画はありますか？ @scottmcmによって提案されたバージョンは問題ないようです。 私は引き続き使用する?と演算子Option 、と私は考えてTry形質は強制しないように変更する必要がありますResult上のセマンティクスをOption 。

@scottmcmの代替手段を使用すると、 ?をOptionとともに使用して、 NoneErrorを取り除くことができます。 私は@nikomatsakis （コメント）に同意します。 Try特性は、「 Option 「失敗」を表すタイプを人為的に定義する」必要性を促進するものではありません。

pub struct Error(Box<dyn std::fmt::Debug>);
impl<T: std::fmt::Debug + 'static> From<T> for Error { fn from(error : T) -> Self { Error(Box::new(error)) } }
type Result<T> = std::result::Result<T, Error>;

ここの初心者、私は取得したいのに少し頑固でしたか？ エラーとオプションの両方を自動的に消去と入力します。
他の可能性のあるソリューションを実装できない理由を理解するために多くの時間を費やした後、 @ cuviperが私が得ることができるものに最も近いことがわかりました。
いくつかの説明が役に立ちましたが、少なくとも私はいくつかのRustメタプログラミングの制限に精通する必要がありました。
それで、それを理解して具体的に説明しようとしました。
このスレッドは、私のような人がこれに遭遇するのを助けてくれる可能性が最も高い交差点のようです。自由に修正してください：

• StdErrorの代わりにDebug（StdErrorとNoneErrorに共通）を使用する：
  一般的なFrom<T: StdError> for Errorと特殊なFrom<NoneError> for Error競合
  NoneErrorがStdErrorを実装した場合はあいまいになるため（明らかに、デフォルトでもオーバーライドを許可せず、排他性を強制します）
  これは、サポートされていない「負の境界」によって解決できます。おそらく、それが唯一のユースケースであるためですか。 （専門以上）
  NoneErrorのimplStdErrorは、StdErrorまたはNoneError自体と一緒にのみ定義できるため、ダウンストリーム全体で一貫性があります。
• エラーをエイリアスにすることはできません：
  type Error = Box<Debug>はデバッグをバインドします。これによりFrom<T:Debug> for ErrorがFrom<T> for Tと競合します（べき等の再帰的From）

したがって、Errorはデバッグを実装できないため、推移的なデバッグを使用して結果にアンラップするヘルパーが必要になる場合があります。

fn from<T>(result : Result<T>) -> std::result::Result<T, Box<dyn std::fmt::Debug>> { match result { Ok(t) => Ok(t), Err(e) => Err(e.0) } }

impl From<Result<T>> for StdResult<T>でもInto<StdResult> for Result<T>かまいません（アップストリームタイプのアップストリーム特性を暗示することはできません）

たとえば、これを使用して、終了のデバッグリターンを取得できます。

fn main() -> std::result::Result<(), Box<dyn std::fmt::Debug>> { from(run()) }

邪悪な考え：多分?演算子はどういうわけかモナディックバインドを表すことができるので、

let x: i32 = something?;
rest of function body

になります

Monad::bind(something, fn(x) {
    rest of function body
})

ひどい考えですが、それは私の内なるオタクを喜ばせます。

@derekdreery returnやcontinueような命令型制御フローではうまく機能しないと思います

?演算子のセマンティクスはすでに安定していることに注意してください。 実際のTry特性のみが不安定であり、変更を加えると、 OptionとResultに対して同じ安定した効果を維持する必要があります。

@KrishnaSannasi

@derekdreeryリターンアンドコンティニューのような命令型制御フローではうまく機能しないと思います

私はこの声明に同意します。

@cuviper

？のセマンティクスに注意してください。 オペレーターはすでに安定しています。 実際のTry特性のみが不安定であり、変更を加えても、OptionとResultに対して同じ安定した効果を維持する必要があります。

これはエポック全体にも当てはまりますか？

もっと一般的に言えば、 .await 、 ?/アーリーリターン、Option :: map、Result :: map、Iterator :: map in rust、のような概念を統一することは不可能だと思います。しかし、これらすべてが何らかの構造を共有していることを理解することは、私がより優れたプログラマーになるのに間違いなく役立ちます。

OTであることをお詫びします。

エポック/エディションで?脱糖を変更できるかどうかはわかりませんが、それは確かにマクロのような多くのクロスクレートの懸念を複雑にします。

安定性の保証とエポックRFCの私の解釈では、 ?動作（砂糖またはその他）は変更される可能性がありますが、 Option / Resultタイプでの現在の動作は維持する必要がありますそれを破ると、私たちが正当化することを望んでいたよりもはるかに多くの解約が発生するため、同じです。

OptionどういうわけかResultタイプエイリアスだった場合Optionどうなりますか？ つまり、 type Option<T> = Result<T, NoValue> 、 Option::<T>::Some(x) = Result::<T, NoValue>::Ok(x) 、 Option::<T>::None = Result::<T, NoValue>::Err(NoValue) ？ これを実装するには魔法が必要であり、現在の言語環境では現実的ではありませんが、探索する価値があるかもしれません。

OptionとResultが異なるタイプであることに依存するトレイトの実装があるため、この変更を行うことはできません。

それを無視すると、さらに一歩進んで、 boolをResult<True, False>エイリアスにすることもできます。ここで、 TrueとFalseはユニットタイプです。

ユニット() Try implを追加することは検討されていますか？ 何も返さない関数の場合、ロギングコールバックなどの重要でない関数でエラーが発生した場合でも、早期の戻りが役立つ場合があります。 または、どのような状況でもエラーを黙って無視しないことが望ましいため、ユニットは除外されましたか？

または、どのような状況でもエラーを黙って無視しないことが望ましいため、ユニットは除外されましたか？

この。 重要でないコンテキストでエラーを無視したい場合は、 unwrapまたはそのバリアントの1つを使用する必要があります。

foo() -> ()ようなもので?を使用できることは、条件付きコンパイルのコンテキストで非常に役立つため、強く検討する必要があります。 それはあなたの質問とは違うと思います。

unwrapまたはそのバリアントの1つを使用する必要があります。

unwrap()はパニックを引き起こすので、重要でない状況で使用することはお勧めしません。 単純な返品が必要な状況では適切ではありません。 ソースコードで?が明示的かつ目に見える形で使用されているため、 ?は完全に「サイレント」ではないという議論をすることができます。 このように、 ?とunwrap()はユニット関数に類似していますが、戻りのセマンティクスが異なります。 私が見る唯一の違いは、 unwrap()は目に見える副作用（プログラムの実行/スタックトレースの出力）を作成し、 ?は作成しないことです。

現在、ユニット関数を早期に返す人間工学は、 ResultまたはOption返す人間工学よりもかなり劣っています。 これらの場合、ユーザーはResultまたはOptionリターンタイプを使用する必要があるため、おそらくこの状況が望ましいでしょう。これにより、APIを変更するインセンティブが提供されます。 いずれにせよ、PRまたはドキュメントにユニットリターンタイプの説明を含めるとよいでしょう。

foo() -> ()ようなもので?を使用できることは、条件付きコンパイルのコンテキストで非常に役立つため、強く検討する必要があります。 それはあなたの質問とは違うと思います。

これはどのように機能しますか？ 常にOk（（））に評価され、無視されますか？

また、これをどこで使いたいのか、例を挙げていただけますか？

ええ、MyCollection :: pushのようなものは、コンパイル時の構成に応じて、コレクションがエラー時にパニックになるように構成されている場合、Result <（）、AllocError>の戻り値または（）の戻り値を持つ可能性があるという考えでした。 コレクションを使用する中間コードはそれについて考える必要はないので、リターンタイプが()場合でも、単に_常に_ ?使用できるのであれば便利です。

ほぼ3年後、これは解決に近づいていますか？

@Lokathorは、リターンタイプResult<Result<X,Y>,Z>または同様のものが不可能な場合にのみ機能します。 しかし、そうです。 したがって、不可能です。

階層化された結果が問題を引き起こす理由がわかりません。 詳しく教えていただけますか？

相互参照の目的で、 @ dureuillによって内部で代替の定式化が提案されてい

https://internals.rust-lang.org/t/a-slightly-more-general-easier-to-implement-alternative-to-the-try-trait/12034

@Lokathor
わかりました、私はそれについてもっと深く考えました、そして私はかなり良い説明を見つけたかもしれないと思います。

注釈の使用

問題は、戻り値の型の解釈、または奇妙な注釈がコードを乱雑にすることです。 それは可能ですが、コードが読みにくくなります。 （前提条件： #[debug_result]は必要な動作を適用し、 Result::Err(...)を返す代わりにリリースモードでパニックになるように関数を変更し、 Result::Okをアンラップしますが、その部分は注意が必要です）

#[debug_result]
fn f() -> Result<X, Y>;

#[debug_result]
fn f2() -> Result<Result<A, B>, Y>;

#[debug_result]
fn g() -> Result<X, Y> {
    // #[debug_result_spoiled]
    let w = f();
    // w could have type X or `Result<X,Y>` based on a #[cfg(debug_...)]
    // the following line would currently only work half of the time
    // we would modify the behavoir of `?` to a no-op if #[cfg(not(debug_...))]
    // and `w` was marked as `#[debug_result]`-spoiled
    let x = w?;

    // but it gets worse; what's with the following:
    let y = f2();
    let z = y?;
    // it has completely different sematics based on a #[cfg(debug_...)],
    // but would (currently?) print no warnings or errors at all,
    // and the type of z would be differently.

    Ok(z)
}

したがって、コードが読みにくくなります。
?単純にno-opに変更することはできません。
特に、 #[debug_result]の戻り値が一時変数に保存され、後で?演算子を使用して「try-propagated」された場合。 ?のセマンティクスは、多くの「変数」に依存するため、非常に混乱します。これらの変数は、「書き込み時」に必ずしも認識されていないか、ソースコードを読み取るだけでは推測が難しい場合があります。 #[debug_result]は、関数値が割り当てられた変数を台無しにする必要がありますが、1つの関数が#[debug_result]マークされていて、そうでない場合は機能しません。たとえば、次のように型エラーが発生します。

// f3 is not annotated
fn f3() -> Result<X, Y>;

// later inside of a function:
   // z2 needs to be both marked spoiled and non-spoiled -> type error
   let z2 = if a() {
       f3()
   } else {
       f()
   };
   // althrough the following would be possible:
   let z2_ = if a() {
       f3()?
   } else {
       f()?
   };

代替：新しいタイプを使用する

「よりクリーンな」ソリューションは、特定のコンパイルフラグが設定され、エラーから構築されたときにパニックになるDebugResult<T, E>タイプである可能性がありますが、それ以外の場合はResult<T, E>と同等です。 しかし、それは現在の提案でも可能だと思います。

@zserikの最後の投稿への返信：あなたが説明したマクロは無意味です-ビルド構成に基づいて関数のreturnタイプを課金すると、実行方法に関係なく、1つだけを除くすべての可能なビルド構成で関数のすべての一致が壊れます。

@ tema3210わかっています。 @Lokathorのアイデアは、実際には一般的に機能しないことを指摘したかっただけです。 部分的に機能する可能性があるのは次のことだけですが、多くの制限があり、長期的には価値がないと思います。

// the result of the fn *must* have Try<Ok=()>
// btw. the macro could be already implemented with a proc_macro today.
#[debug_result]
fn x() -> Result<(), XError> {
  /* ..{xbody}.. */
}

// e.g. evaluates roughly to:
//..begin eval
fn x_inner() -> Result<(), XError> {
  /* ..{xbody}.. */
}

#[cfg(panic_on_err)]
fn x() {
  let _: () = x_inner().unwrap();
}
#[cfg(not(panic_on_err))]
fn x() -> Result<(), XError> {
  x_innner()
}

//..end eval

fn y() -> Result<(), YError> {
  /* ... */
  // #[debug_result] results can't be matched on and can't be assigned to a
  // variable, they only can be used together with `?`, which would create
  // an asymetry in the type system, but could otherwise work, althrough
  // usage would be extremely restricted.
  x()?;
  // e.g. the following would fail to compile because capturing the result
  // is not allowed
  if let Err(z) = x() {
    // ...
  }
}

@zserik実際にこのような形をとることは可能ですか？

#[cfg(panic_on_err)]
fn x() -> Result<(), !> {
  let _: () = x_inner().unwrap();
}

#[cfg(not(panic_on_err))]
fn x() -> Result<(), XError> {
  x_innner()
}

わかりました、いい考えです。

これが安定化の前に説明する必要があるものかどうかはよくわかりませんが、エラーリターントレースの実装に興味があり、 Tryトレイトまたは少なくとも提供されている実装の変更が含まれていると思いますそれを機能させるためにResultために。 最終的にはこれをRFCに変換する予定ですが、RFCの作成に時間がかかる場合に備えて、後で追加できないようにtryトレイトが安定していないことを確認したいと思います。 基本的な考え方はこれです。

下位互換性を維持するために、特殊化とTのデフォルトのimplを使用する追跡情報を渡すために使用する特性があります。

pub trait Track {
    fn track(&mut self, location: &'static Location<'static>);
}

default impl<T> Track for T {
    fn track(&mut self, _: &'static Location<'static>) {}
}

そして、あなたが変更Tryための実装Result使用するようにtrack_caller 、内側型にこの情報を渡し、

    #[track_caller]
    fn from_error(mut v: Self::Error) -> Self {
        v.track(Location::caller());
        Self::Err(v)
    }

そして、バックトレースを収集したいタイプの場合は、Trackを実装します

#[derive(Debug, Default)]
pub struct ReturnTrace {
    frames: Vec<&'static Location<'static>>,
}

impl Track for ReturnTrace {
    fn track(&mut self, location: &'static Location<'static>) {
        self.frames.push(location);
    }
}

使用法は次のようになります

#![feature(try_blocks)]
use error_return_trace::{MyResult, ReturnTrace};

fn main() {
    let trace = match one() {
        MyResult::Ok(()) => unreachable!(),
        MyResult::Err(trace) => trace,
    };

    println!("{:?}", trace);
}

fn one() -> MyResult<(), ReturnTrace> {
    try { two()? }
}

fn two() -> MyResult<(), ReturnTrace> {
    MyResult::Err(ReturnTrace::default())?
}

そして、バックトレースの非常にくだらないバージョンの出力は次のようになります

ReturnTrace { frames: [Location { file: "examples/usage.rs", line: 18, col: 42 }, Location { file: "examples/usage.rs", line: 14, col: 16 }] }

そして、これが実際の概念実証ですhttps://github.com/yaahc/error-return-traces

トレイト実装を

trait Try{
     type Error;
     type Ok;
     fn into_result(self)->Result<Self::Ok,Self::Error>;
     fn from_ok(val: Self::Ok)->Self;
     fn from_error<T>(val: T)->Self;
}

コンパイラはfrom_error単一化して、 From::from呼び出しを回避でき、さまざまなエラータイプのメソッドimplを手動で提供できるため、 ?演算子でさまざまな「アンラップ」を実行できることに注意してください。エラーの種類。

 fn from_error<T>(val: T)->Self;

書かれているように、実装者は制約のない任意のサイズのTを受け入れる必要があります。 これをカスタム制約にする場合は、 Try<T>ようなトレイトパラメーターである必要があります。 これは、 @ scottmcmがhttps://github.com/rust-lang/rust/issues/42327#issuecomment-457353299で行ったTryBlock / Bubble<Other>組み合わせに似ています。

書かれているように、実装者は制約のない任意のサイズのTを受け入れる必要があります。 これをカスタム制約にする場合は、 Try<T>ようなトレイトパラメーターである必要があります。 これは、 @ scottmcmが＃42327（コメント）で持っていたTryBlock / Bubble<Other>組み合わせに似ています。

つまり、使用法は次のようになります。

trait Try{
     //same from above
}
struct Dummy {
    a: u8,
}
struct Err1();
struct Err2();
impl Try for Dummy {
    type Ok=();
    type Error=();

    fn into_result(self)->Result<Self::Ok,Self::Error>{
        std::result::Result::Ok(())
    }
    fn from_ok(val: Self::Ok)->Self{
        Self{a: 0u8}
    }
    fn from_error<T>(val: Err1)->Self where T == Err1{
        Self{a: 1u8}
    }
    fn from_error<T>(val: Err2)->Self where T == Err2{
        Self{a: 2u8}
    }
}

TryとTryFromErrorを分割する必要があります。 私は元の提案fwiwよりもそれが好きですが、新しいRFCが必要だと思います。

（そして、それは「試行」ではなく「伝播」と呼ばれるべきだったと私はまだ思っていますが、私は逸脱します）

@ tema3210私はあなたの意図を理解していると思いますが、それは有効なRustではありません。

@ SoniEx2

TryとTryFromErrorを分割する必要があります。

そうです、それが私がTryBlock / Bubble<Other>デザインについて言及した理由です。 その命名の選択について議論することはできますが、早期返品は必ずしもそれ自体が_エラー_に関するものではないという考えでした。 たとえば、内部のIteratorメソッドの多くは、カスタムのLoopStateタイプを使用しています。 findようなものの場合、探しているものを見つけるのはエラーではありませんが、そこで反復を停止したいと思います。

https://github.com/rust-lang/rust/blob/3360cc3a0ea33c84d0b0b1163107b1c1acbf2a69/src/libcore/iter/mod.rs#L375 -L378

その命名の選択については議論の余地がありますが、アーリーリターンは必ずしもエラーそのものではないという考えでした。

正確には、「try」という名前が好きではなく、「propagate」という名前を好む理由です。これは、「初期の」戻り値を「伝播」するためです：p

（これが理にかなっているかどうかわかりませんか？前回これを取り上げたとき、「伝播」することは何らかの理由で私には理にかなっており、他の人にそれを説明することはできませんでした。）

この特性は、デフォルトの?動作feを上書きして、デバッグ情報（ファイル/行番号など）をログに記録するログフックfeを追加しようとするときに役立ちますか？

現在、stdlibマクロの上書きはサポートされていますが、 ?演算子がtry!マクロに明示的に変換されていないようです。 それは残念です。

@stevenroose Tryトレイトのみにサポートを追加するには、 ? 「発生した」場所に関するファイルの場所情報を含めるようにTryトレイトを変更する必要があります。 。

@stevenroose Tryトレイトのみにサポートを追加するには、 ? 「発生した」場所に関するファイルの場所情報を含めるようにTryトレイトを変更する必要があります。 。

これは正しくありません。トレイト定義にアノテーションが含まれていない場合でも、＃[track_caller]をトレイトimplで使用できます。

@stevenrooseがあなたの質問に答えます、はい、しかし、?場所を印刷することに興味がある場合は、上からエラーリターントレースコメントをチェックする必要があります

https://github.com/rust-lang/rust/issues/42327#issuecomment -619218371

誰かがすでにこれについて言及しているかどうかはわかりませんが、 impl Try for bool 、多分Try<Ok=(), Error=FalseError>でしょうか？
このようなことができるように

fn check_key(v: Vec<A>, key: usize) -> bool {
  let x = v.get_mut(key)?; // Option
  x.is_valid()?; // bool
  x.transform()?; // Result
  true
}

?コードがより明確になると思うほとんどの場合、リターンタイプOption<()>を使用する必要があります。

誰かがすでにこれについて言及しているかどうかはわかりませんが、 impl Try for bool 、多分Try<Ok=(), Error=FalseError>でしょうか？

これにより、 Tryはboolの&&演算子として動作します。 他の人が上で指摘したように、成功時に短絡するユースケースもあります。その場合、 Tryは||として動作するはずです。 &&演算子と||演算子は入力するのにそれほど長くはかからないので、この実装を使用することの利点もあまりわかりません。

@calebsander親切に返信してくれてありがとう。
これはいくつかの単純なケースに当てはまりますが、そうなることはあまりないと思います。特に、式にlet x = v.get_mut(key)?ような割り当てステートメントを含めることはできません。
&&と||が常にうまくいく場合は、 .unwrap_or_else() 、 .and_then()をOptionとErrorプレイすることもできます。
流れるコードを&&と||表現できますか？

fn check_key(v: Vec<A>, key: usize) -> bool {
  let x = v.get_mut(key)?; // Option
  x.not_valid().not()?; // bool
  for i in x.iter() {
    if i == 1 { return true }
    if i == 2 { return false }
    debug!("get {}" i);
  }
  let y = x.transform()?; // Result
  y == 1
}

true失敗を意味し、 false成功を意味するという条件では、 !expr?は混乱を招く可能性がありますが、 expr.not()?を使用してトリックを実行できます（注： ops::Try 、 Errorに対して常にfalseがあります）

これはいくつかの単純なケースに当てはまりますが、そうなることはあまりないと思います。特に、式にlet x = v.get_mut(key)?ような割り当てステートメントを含めることはできません。

ええと、私があなたの提案を誤解しない限り、 bool Try<Ok = (), Error = FalseError>を実装するだけではこれは許されません。 ?演算子がNoneをfalse変換できるように、 impl From<NoneError> for FalseErrorも必要になります。 （同様に、 boolを返す関数内のResult<T, E> ?を適用する場合は、 impl From<E> for FalseErrorを実行する必要があります。ブランケットの実装には問題があります。）戻り値Result<bool, bool> （ .unwrap_or_else(|err| err)折りたたむことができます）で問題がなければ、 some_option().ok_or(false)?とsome_result().map_err(|_| false)?使用することもできます。 .unwrap_or_else(|err| err) ）。

他のTryエラーをboolに変換する問題は別として、 bool提案しているTry実装は、 &&演算子にすぎません。 たとえば、これらは同等です

fn using_try() -> bool {
    some_bool()?;
    some_bool()?;
    some_bool()
}

と

fn using_and() -> bool {
    some_bool() &&
    some_bool() &&
    some_bool()
}

（確かに、 ifやloopような非()を返す制御フローは、変換が簡単ではありません。）

true失敗を意味し、 false成功を意味するという条件では、 !expr?は混乱を招く可能性がありますが、 expr.not()?を使用してトリックを実行できます（注： ops::Try 、 Errorに対して常にfalseがあります）

falseがError場合を表す必要があるかどうかは私にはわかりません。 （たとえば、 Iterator.all()はfalseを短絡させたいのですが、 Iterator::any()は代わりにtrueを求めます。）ご指摘のとおり、 ?渡された値を反転する（そして関数の戻り値も反転する）ことによる反対の短絡動作。 しかし、それが非常に読みやすいコードになるとは思いません。 2つの異なる動作を実装する別々のstruct s And(bool)とOr(bool)を使用する方が理にかなっている場合があります。

同様に、あなたが適用したい場合は？ 結果にboolを返す関数内では、Fromを実装する必要があります。FalseErrorの場合。 このような包括的な実装には問題があると思います。

いいえ、私はしたくないimpl From<T> for FalseError多分私たちが行うことができ、 result.ok()?

falseがエラーの場合を表す必要があるかどうかは私にはわかりません。

trueをSomeマップするtrue bool::thenあると、どういうわけか自然だと思います。

私はそれを逃した場合、私を許して-なぜdoesntのNoneError IMPL std::error::Error ？ これにより、 Box<dyn Error>などを返す関数には使用できなくなります。

私はそれを逃した場合、私を許して-なぜdoesntのNoneError IMPL std::error::Error ？ これにより、 Box<dyn Error>などを返す関数には使用できなくなります。

ここではない専門家が、私はのために便利なエラーメッセージを思い付くしようとすると重大な問題を見ることができる「何かがいたNoneとあなたはそれがあることが予想Some基本的に何をしています（」ここで得られるだろう-いくつかの診断メッセージ）。 私の経験では、 Option::ok_or_elseコンビネータを使用して、代わりに別のエラータイプを使用するのが常に最も理にかなっています。これは、呼び出し元のコードとして、とにかく与えるコンテキストがはるかに優れているためです。

@ErichDonGublerに同意します。 ?をOption ?と一緒に使用できないのは非常に面倒ですが、それは正当な理由であり、言語ユーザーとして、エラーを適切に処理することは誰にとっても最善の利益だと思います。 ?実行するだけでなく、エラーコンテキストをNoneにバインドするというこの余分な作業を実行することは、本当に本当に面倒ですが、エラーを適切に伝達することを余儀なくされます。

Noneエラーとして解釈できるようにするのは、非常に大まかなプロトタイピングの場合だけです。 Option::todo_err()呼び出しのようなものを追加すると、内部値のOkが返されますが、 Noneパニックになると思いました。 コードオーサリングの「ラフプロトタイピング」モードのニーズを分析するまでは、非常に直感的ではありません。 Ok(my_option.unwrap())と非常によく似ていますが、 Ok(...)ラッピングは必要ありません。 さらに、「todo」の性質を明示的に指定することで、このコードを本番ロジックから削除し、適切なエラーバインディングに置き換える意図を伝えます。

しかし、なしでパニックになります

これはunwrapままにしておくべきだと強く感じています。 todo_errを追加した場合、実際のエラータイプが返されるはずです。これにより、どのエラータイプを返すかという疑問が生じます。

また、 fn todo_err(self) -> Result<Self, !>には、安定するために!が必要になるという明らかな問題があると思います。これは、いつかはそうですね。

私のユースケースは確かに大まかなプロトタイピングであり、エラーをあまり気にしません。 NoneError全体があなたがリストしたこれらの問題に苦しんでいませんか？ それが存在するべきであると決定された場合（少なくともプロトタイピングにとっては良いことだと思います）、1つと名付けられているのでErrorを暗示する必要があると思います。

このimplがないタイプのため、私はそれに.ok_or("error msg")をたたくだけに頼りました。これも機能しますが、あまり便利ではありません。