let mut child = Command::new(&spawn_actor.executable);
    if spawn_actor.pass_id {
        child.arg(uuid.to_string());
    }
    let mut child = child
        .args(&spawn_actor.args)

    let mut child = Command::new(&spawn_actor.executable)
        .args(
            &spawn_actor
                .args
                .iter()
                .map(|s| s.replace("{ACTOR_ID}", &uuid.to_string()))
                .collect::<Vec<_>>(),
        )

    _ = spawn_actor(
        &Props {
            executable,
            args,
            pass_id: true,
        },
        true,
        tx.clone(),
    )
    .await?;

    _ = spawn_actor(&Props { executable, args }, true, tx.clone()).await?;

    pub pass_id: bool,

use uuid::Uuid;

    my_id: Uuid,

                        pass_id: false,

This is an experiment to use unix processes as actors.

This is an experiment to use unix processes as actors. This is also probably the worst actor framework in existence,
but its quite small so there's that.
This will probably be outperformed be any halfway decent actor framework, because it uses the unix scheduler to schedule
its work. This simplifies the architecture quite a bit, so that everything that can read and write from stdin/stdout and
parse json can act as an actor in this system.

Each actor gets passed its ID as its first argument.

A props message takes the arguments from the props and spawns the executable according to the props.

A props message takes the arguments from the props and spawns the executable according to the props. If one of the
arguments contains the string "{ACTOR_ID}", then this will be replaced by the id of the actor itself.

Or a data message from another actor.

Or a data message from another actor.
The data structures for the protocol can be found in [src/lib.rs](src/lib.rs).

.git
.DS_Store
.pijul
/target