Attribute Macro Transmitter 

#[Transmitter]

In situations where the transmitting backend for a channel is generic, explicitly writing down all the trait bounds necessary to implement a protocol for that parameterized backend can be a lot of boilerplate. The Transmitter attribute macro abbreviates these bounds by modifying the where clause of the item to which it is attached.

This macro may be attached to any item capable of supporting a where-clause: an enum definition, fn item (top level or in a trait definition or implementation), impl block, struct definition, trait definition, type synonym, or union definition.

Examples

use dialectic::prelude::*;

#[Transmitter(Tx for bool, i64)]
async fn foo<Tx, Rx>(
    chan: Chan<Session!{ send bool; send i64 }, Tx, Rx>
) -> Result<(), Tx::Error>
where
    Rx: Send + 'static,
{
    let chan = chan.send(true).await?;
    let chan = chan.send(42).await?;
    chan.close();
    Ok(())
}

Syntax

The Transmitter attribute takes the name of the transmitter for which the bounds will be generated, an optional calling convention (one of move, ref, or mut), and, optionally, the keyword for followed by a comma-separated list of types.

Some example invocations:

#[Transmitter(Tx)]
#[Transmitter(Tx)]
#[Transmitter(Tx for bool)]
#[Transmitter(Tx for ref bool)]
#[Transmitter(Tx for ref mut bool)]
#[Transmitter(Tx for bool, i64, Vec<String>)]
#[Transmitter(Tx for bool, ref i64, ref mut Vec<String>)]

Expansion

The attribute adds extra bounds to the where-clause of the item to which it is attached (if the item does not have a `where-clause, one will be created containing the bounds).

For a transmitter type Tx, optional calling conventions CN? (none, or one of move, ref, or mut), and types T1, T2, ..., the invocation:

#[Transmitter(Tx for C1? T1, C2? T2, ...)]
fn f<Tx>() {}

…translates to the following bounds:

use dialectic::prelude::*;

fn f<Tx>()
where
    Tx: Transmitter + Send + 'static,
    // For each of the types `T1`, `T2`, ...
    // If the convention is unspecified, `C` is left unspecified;
    // otherwise, we translate into `call_by` conventions using
    // `move` => `Val`, `ref` => `Ref`, and `mut` => `Mut`
    Tx: Transmit<T1, C1>,
    Tx: Transmit<T2, C2>,
    // ...
{}