Enum nom::lib::std::ops::ControlFlow

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

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

new API

[−] Expand description

Used to tell an operation whether it should exit early or go on as usual.

This is used when exposing things (like graph traversals or visitors) where you want the user to be able to choose whether to exit early. Having the enum makes it clearer – no more wondering “wait, what did false mean again?” – and allows including a value.

Examples

Early-exiting from Iterator::try_for_each:

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

let r = (2..100).try_for_each(|x| {
    if 403 % x == 0 {
        return ControlFlow::Break(x)
    }

    ControlFlow::Continue(())
});
assert_eq!(r, ControlFlow::Break(13));

A basic tree traversal:

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

pub struct TreeNode<T> {
    value: T,
    left: Option<Box<TreeNode<T>>>,
    right: Option<Box<TreeNode<T>>>,
}

impl<T> TreeNode<T> {
    pub fn traverse_inorder<B>(&self, mut f: impl FnMut(&T) -> ControlFlow<B>) -> ControlFlow<B> {
        if let Some(left) = &self.left {
            left.traverse_inorder(&mut f)?;
        }
        f(&self.value)?;
        if let Some(right) = &self.right {
            right.traverse_inorder(&mut f)?;
        }
        ControlFlow::Continue(())
    }
}

Variants

Continue(C)

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

new API

[−] Expand description

Move on to the next phase of the operation as normal.

Break(B)

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

new API

[−] Expand description

Exit the operation without running subsequent phases.

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.

Examples

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

assert!(ControlFlow::<i32, String>::Break(3).is_break());
assert!(!ControlFlow::<String, i32>::Continue(3).is_break());

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.

Examples

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

assert!(!ControlFlow::<i32, String>::Break(3).is_continue());
assert!(ControlFlow::<String, i32>::Continue(3).is_continue());

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.

Examples

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

assert_eq!(ControlFlow::<i32, String>::Break(3).break_value(), Some(3));
assert_eq!(ControlFlow::<String, i32>::Continue(3).break_value(), None);

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, [+]

[+] Show hidden undocumented items

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, [+]

[+] Show hidden undocumented items

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>, [+]

[+] Show hidden undocumented items

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>[+]

[+] Show hidden undocumented items

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.