Expand description


A small crate providing a primitive for the execution of asynchronous tasks by managers through signals.


async fn main() {
    pub enum Signal {

    pub struct Mgr {
        greeting: String,
    impl telecomande::Manager for Mgr {
        type Signal = Signal;
        async fn handle(&mut self, signal: Self::Signal) {
            match signal {
                Signal::Greet => println!("{}", self.greeting),
                Signal::Say(text) => println!("{text}"),

    let manager = Mgr {
        greeting: "Hello".into(),
    let handle = telecomande::spawn(manager);

    let remote = handle.remote();
    tokio::spawn(async move {

    //   out:
    // Hello
    // telecomande


A handle to a task running a crate::Processor.

Represents a shareable/clonable remote to a task running a crate::Processor. Used to send crate::Command to that task. Initially constructed by the crate::Handle returned on the crate::Executor::spawn of the task.

Simple implementation of crate::Executor, process incomming crate::Commands one by one.


Autotrait that constraints the commands that can be sent to a crate::Processor. not ment to be implemented manually

Autotrait that constraints the kind of errors that can be returned by a crate::Processor. not ment to be implemented manually

Internal data of a task running and handling incomming crate::Command for a crate::Processor.

Represents the handling of crate::Command in a task. consumed by a crate::Executor.

Attribute Macros