Enum sp_std::ops::ControlFlow

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

🔬 This is a nightly-only experimental API. (control_flow_enum)

new API

Used to make try_fold closures more like normal loops

Variants

Continue(C)

🔬 This is a nightly-only experimental API. (control_flow_enum)

new API

Continue in the loop, using the given value for the next iteration

Break(B)

🔬 This is a nightly-only experimental API. (control_flow_enum)

new API

Exit the loop, yielding the given value

Implementations

impl<B, C> ControlFlow<B, C>

pub fn is_break(&self) -> bool

🔬 This is a nightly-only experimental API. (control_flow_enum)

new API

Returns true if this is a Break variant.

pub fn is_continue(&self) -> bool

🔬 This is a nightly-only experimental API. (control_flow_enum)

new API

Returns true if this is a Continue variant.

pub fn break_value(self) -> Option<B>

🔬 This is a nightly-only experimental API. (control_flow_enum)

new API

Converts the ControlFlow into an Option which is Some if the ControlFlow was Break and None otherwise.

pub fn map_break<T, F>(self, f: F) -> ControlFlow<T, C> where
    F: FnOnce(B) -> T, 

🔬 This is a nightly-only experimental API. (control_flow_enum)

new API

Maps ControlFlow<B, C> to ControlFlow<T, C> by applying a function to the break value in case it exists.

impl<R> ControlFlow<R, <R as Try>::Ok> where
    R: Try, 

pub fn from_try(r: R) -> ControlFlow<R, <R as Try>::Ok>

🔬 This is a nightly-only experimental API. (control_flow_enum)

new API

Create a ControlFlow from any type implementing Try.

pub fn into_try(self) -> R

🔬 This is a nightly-only experimental API. (control_flow_enum)

new API

Convert a ControlFlow into any type implementing Try;

impl<B> ControlFlow<B, ()>

pub const CONTINUE: ControlFlow<B, ()>

🔬 This is a nightly-only experimental API. (control_flow_enum)

new API

It's frequently the case that there's no value needed with Continue, so this provides a way to avoid typing (()), if you prefer it.

Examples

#![feature(control_flow_enum)]
use std::ops::ControlFlow;

let mut partial_sum = 0;
let last_used = (1..10).chain(20..25).try_for_each(|x| {
    partial_sum += x;
    if partial_sum > 100 { ControlFlow::Break(x) }
    else { ControlFlow::CONTINUE }
});
assert_eq!(last_used.break_value(), Some(22));

impl<C> ControlFlow<(), C>

pub const BREAK: ControlFlow<(), C>

🔬 This is a nightly-only experimental API. (control_flow_enum)

new API

APIs like try_for_each don't need values with Break, so this provides a way to avoid typing (()), if you prefer it.

Examples

#![feature(control_flow_enum)]
use std::ops::ControlFlow;

let mut partial_sum = 0;
(1..10).chain(20..25).try_for_each(|x| {
    if partial_sum > 100 { ControlFlow::BREAK }
    else { partial_sum += x; ControlFlow::CONTINUE }
});
assert_eq!(partial_sum, 108);

Trait Implementations

impl<B, C> Clone for ControlFlow<B, C> where
    C: Clone,
    B: Clone, 

pub fn clone(&self) -> ControlFlow<B, C>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B, C> Copy for ControlFlow<B, C> where
    C: Copy,
    B: Copy, 

impl<B, C> Debug for ControlFlow<B, C> where
    C: Debug,
    B: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<B, C> PartialEq<ControlFlow<B, C>> for ControlFlow<B, C> where
    C: PartialEq<C>,
    B: PartialEq<B>, 

pub fn eq(&self, other: &ControlFlow<B, C>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &ControlFlow<B, C>) -> bool

This method tests for !=.

impl<B, C> StructuralPartialEq for ControlFlow<B, C>

impl<B, C> Try for ControlFlow<B, C>

type Ok = C

🔬 This is a nightly-only experimental API. (try_trait)

The type of this value when viewed as successful.

type Error = B

🔬 This is a nightly-only experimental API. (try_trait)

The type of this value when viewed as failed.

pub fn into_result(
    self
) -> Result<<ControlFlow<B, C> as Try>::Ok, <ControlFlow<B, C> as Try>::Error>

🔬 This is a nightly-only experimental API. (try_trait)

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.

pub fn from_error(v: <ControlFlow<B, C> as Try>::Error) -> ControlFlow<B, C>

🔬 This is a nightly-only experimental API. (try_trait)

Wrap an error value to construct the composite result. For example, Result::Err(x) and Result::from_error(x) are equivalent.

pub fn from_ok(v: <ControlFlow<B, C> as Try>::Ok) -> ControlFlow<B, C>

🔬 This is a nightly-only experimental API. (try_trait)

Wrap an OK value to construct the composite result. For example, Result::Ok(x) and Result::from_ok(x) are equivalent.