You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: round_robin_dispatcher.rs
    path of file: ./repos/bastion/src/bastion/examples
    
    the code of the file until where you have to start completion: use bastion::prelude::*;
use futures_timer::Delay;
use std::sync::Arc;
use std::time::Duration;
use tracing::Level;

///
/// Prologue:
/// This example demonstrate a idiomatic way to implement the round robin
/// algorithm with bastion. We will use two groups of children, one will be
/// supervised by a dispatcher, named `Receiver`, the other one will call it.
/// Both groups will be supervised by the supervisor.
///
///         Bastion
///            |
///        Supervisor     
///       /          \
///    Caller      Receiver
///      |            |
///   Children     Children
///
/// 1. We want a group of children which will broadcast a message to a defined
/// target with a defined data.
/// 2. We want a group of children for receive and print the message.
/// 3. We want to use a dispatcher on the second group because we d
    
fn receiver_group(children: Children) -> Children {
    // We create the second group of children
    children
        // We want to have a disptacher named `Receiver`
        .with_dispatcher(Dispatcher::with_type(DispatcherType::Named(
            "Receiver".to_string(),
        )))
        // We create the function to exec when each children is called
        .with_exec(move |ctx: BastionContext| {
            async move {
                // We create a loop which run as long as the disptacher is alive
                loop {
                    msg! {
                        // We are waiting a msg
                        ctx.recv().await?,
                        // We define the behavior when we receive a new msg
                        raw_message: Arc<SignedMessage> => {
                            // We open the message
                            let message = Arc::try_unwrap(raw_message).unwrap();
                            msg! {
                                message,
                                // Because it's a broadcasted message we can use directly the ref
                                ref data: &str => {
                                    // And we print it
                                    tracing::warn!("Received {}", data);
                                };
                                _: _ => ();
                            }
                        };
                        _: _ => ();
                    }
                }
            }
        })
}