Struct Select

pub struct Select<Bits, S, B, T> { /* private fields */ }

This is the type produced by the inline! macro unless the static; option is enabled.

Note that second type parameter T in the Select type cannot be named. If you want to embed a selection inside of another type have a look at StaticSelect.

See the select! and inline! macros for documentation on syntax and use.

Examples

use std::time::Duration;

use selectme::{Random, Select};
use tokio::time;

let s1 = time::sleep(Duration::from_millis(100));
let s2 = time::sleep(Duration::from_millis(200));

let mut inlined_var = false;

let output: Select<u8, _, Random, _> = selectme::inline! {
    () = s1 => {
        inlined_var = true;
        Some(1)
    }
    _ = s2 => Some(2),
    else => None,
};

tokio::pin!(output);

while let Some(output) = output.as_mut().next().await {
    dbg!(output);
}

dbg!(inlined_var);

Implementations

impl<Bits, S, B, T, O> Select<Bits, S, B, T>

where Bits: Number, B: Bias<Bits>, T: FnMut(&mut Context<'_>, Pin<&mut S>, &mut Set<Bits>, u32) -> Poll<O>,

pub async fn next(self: Pin<&mut Self>) -> O

Get the next element from this select when pinned.

Examples

use std::time::Duration;

use tokio::time;

#[selectme::main]
pub(crate) async fn main() {
    let s1 = time::sleep(Duration::from_millis(100));
    let s2 = time::sleep(Duration::from_millis(200));

    let output = selectme::inline! {
        () = s1 => Some(1),
        _ = s2 => Some(2),
        else => None,
    };

    tokio::pin!(output);

    let mut values = Vec::new();

    while let Some(output) = output.as_mut().next().await {
        values.push(output);
    }

    assert_eq!(values, &[1, 2]);
}

pub fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<O>

Poll for the next branch to resolve in this Select.

Trait Implementations

impl<Bits, S, B, O> Debug for Select<Bits, S, B, O>

where Bits: Number, B: Debug, S: Debug,

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

Formats the value using the given formatter.

impl<Bits, S, B, T, O> Future for Select<Bits, S, B, T>

where Bits: Number, B: Bias<Bits>, T: FnMut(&mut Context<'_>, Pin<&mut S>, &mut Set<Bits>, u32) -> Poll<O>,

type Output = O

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.