A quick demo of using DynClone on a trait so structs with `dyn TraitName` can derive Clone

rust-dynclone-example.rs

#!/usr/bin/env cargo +nightly -Zscript

//! ```cargo
//! [dependencies]
//! dyn-clone = "1.0.12"
//! ```

use std::fmt::Debug;
use dyn_clone::DynClone;

trait AProvider: DynClone + Debug {
    fn provider_name(&self) -> &str;
}

dyn_clone::clone_trait_object!(AProvider);

#[derive(Clone, Debug)]
struct AXProvider {}
impl AProvider for AXProvider {
    fn provider_name(&self) -> &str {
        "AXProvider"
    }
}

#[derive(Clone, Debug)]
struct AYProvider {}
impl AProvider for AYProvider {
    fn provider_name(&self) -> &str {
        "AYProvider"
    }
}

#[derive(Clone, Debug)]
struct AController {
    providers: Vec<Box<dyn AProvider>>,
}

impl AController {
    pub fn print_providers(&self) {
        for p in &self.providers {
            println!("{}", p.provider_name());
        }
    }
}

trait HasAController {
    fn a_controller(&self) -> &AController;
}


#[derive(Clone, Debug)]
struct AppState {
    a_controller: AController,
}

impl HasAController for AppState {
    fn a_controller(&self) -> &AController {
        &self.a_controller
    }
}

fn main() {
    let x = AXProvider{};
    let y = AYProvider{};

    let ac = AController {
        providers: vec![
            Box::new(x),
            Box::new(y)
        ],
    };

    let state = AppState {
        a_controller: ac,
    };


    needs_acontroller(&state)
}

fn needs_acontroller<S: HasAController>(state: &S) {
    state.a_controller().print_providers();
}