Struct dialectic::Branches

#[must_use]pub struct Branches<Choices, Tx, Rx> where
    Tx: Send + 'static,
    Rx: Send + 'static,
    Choices: Tuple + 'static,
    Choices::AsList: EachScoped + EachHasDual + HasLength,  { /* fields omitted */ }

The result of offer: an N-ary enumeration of the possible Chans that could result from the what the other party chooses.

To find out which protocol was selected by the other party, use Branches::case (the analogue to a match statement on Branches).

💡 When possible, prefer the offer! macro over using Branches and case. It guarantees exhaustiveness, and is more concise, readable, and asymptotically efficient.

Implementations

impl<Tx, Rx, Choices, const LENGTH: usize> Branches<Choices, Tx, Rx> where
    Choices: Tuple + 'static,
    Choices::AsList: EachScoped + EachHasDual + HasLength,
    <Choices::AsList as HasLength>::Length: ToConstant<AsConstant = Number<LENGTH>>,
    Tx: Send + 'static,
    Rx: Send + 'static, 

pub fn case<const N: usize>(
    self
) -> Result<Chan<<Choices::AsList as Select<<Number<N> as ToUnary>::AsUnary>>::Selected, Tx, Rx>, Branches<<<Choices::AsList as Select<<Number<N> as ToUnary>::AsUnary>>::Remainder as List>::AsTuple, Tx, Rx>> where
    Number<N>: ToUnary,
    Choices::AsList: Select<<Number<N> as ToUnary>::AsUnary>,
    <Choices::AsList as Select<<Number<N> as ToUnary>::AsUnary>>::Selected: Session,
    <Choices::AsList as Select<<Number<N> as ToUnary>::AsUnary>>::Remainder: EachScoped + EachHasDual + HasLength + List, 

Check if the selected protocol in this Branches was the Nth protocol in its type. If so, return the corresponding channel; otherwise, return all the other possibilities.

pub fn choice(&self) -> Choice<LENGTH>

Determine the Choice which was made by the other party, indicating which of these Branches should be taken.

Ordinarily, you should prefer the offer! macro in situations where you need to know this value.

impl<'a, Tx, Rx> Branches<(), Tx, Rx> where
    Tx: Send + 'static,
    Rx: Send + 'static, 

pub fn empty_case<T>(self) -> T

Eliminate an empty Branches, returning any type. Any code in which this function can be called is unreachable, because it’s impossible to construct an empty Branches.

Trait Implementations

impl<Choices, Tx, Rx> Debug for Branches<Choices, Tx, Rx> where
    Tx: Send + 'static,
    Rx: Send + 'static,
    Choices: Tuple + 'static,
    Choices::AsList: EachScoped + EachHasDual + HasLength,
    Tx: Debug,
    Rx: Debug, 

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

Formats the value using the given formatter.

impl<Tx, Rx, Choices> Drop for Branches<Choices, Tx, Rx> where
    Tx: Send + 'static,
    Rx: Send + 'static,
    Choices: Tuple + 'static,
    Choices::AsList: EachScoped + EachHasDual + HasLength, 

fn drop(&mut self)

Executes the destructor for this type.