Struct SelectorFixed 

pub struct SelectorFixed<const N: usize, T> { /* private fields */ }

Wraps a fixed number of choices and provides methods that guarantee selection from those choices, where N is the possible number of choices set at compile time.

Implementations

impl<const N: usize, T> SelectorFixed<N, T>

pub fn with<const K: usize, C>(self, chooser: C) -> [T; K]

where C: FnOnce([Choice<'_, T>; N]) -> [Choice<'_, T>; K],

The function chooser is used to choose from our provided choices by returning a K-selection of them. The values of these choices are then returned by the function.

use choose_from::select_from_fixed;
let choices = ["Hi", "how", "are ya?"];

let chosen = select_from_fixed(choices).with(|[first, second, third]| {
    // the provided choices allow inspection of the values
    assert_eq!(*first, "Hi");
     
    // this is our selection
    [first, third]
});

assert_eq!(chosen, ["Hi", "are ya?"]);

pub fn any_with<C>(self, chooser: C) -> Vec<T>

where C: FnOnce([Choice<'_, T>; N]) -> Vec<Choice<'_, T>>,

Like with, but for returning any number of chosen values. Use this when you want to ensure some values come from the choices, but the amount of chosen values returned doesn’t matter

use choose_from::select_from_fixed;

let choices = ["Hi", "how", "are ya?"];

let chosen = select_from_fixed(choices).any_with(|choices| {
    choices.into_iter().step_by(2).collect()
});

assert_eq!(chosen, ["Hi", "are ya?"]);

Trait Implementations

impl<const N: usize, T: Debug> Debug for SelectorFixed<N, T>

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

Formats the value using the given formatter.

impl<const N: usize, T: Hash> Hash for SelectorFixed<N, T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const N: usize, T: PartialEq> PartialEq for SelectorFixed<N, T>

fn eq(&self, other: &SelectorFixed<N, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize, T: Eq> Eq for SelectorFixed<N, T>

impl<const N: usize, T> StructuralPartialEq for SelectorFixed<N, T>