Clone trait that is dyn-compatible
==================================

[github](https://github.com/dtolnay/dyn-clone)
[crates.io](https://crates.io/crates/dyn-clone)
[docs.rs](https://docs.rs/dyn-clone)
[build status](https://github.com/dtolnay/dyn-clone/actions?query=branch%3Amaster)

This crate provides a `DynClone` trait that can be used in trait objects, and a
`clone_box` function that can clone any sized or dynamically sized
implementation of `DynClone`. Types that implement the standard library's
[`std::clone::Clone`] trait are automatically usable by a `DynClone` trait
object.

[`std::clone::Clone`]: https://doc.rust-lang.org/std/clone/trait.Clone.html

The signature of `clone_box` is:

```rust
fn clone_box<T>(t: &T) -> Box<T>
where
    T: ?Sized + DynClone
```

## Example

```rust
use dyn_clone::DynClone;

trait MyTrait: DynClone {
    fn recite(&self);
}

impl MyTrait for String {
    fn recite(&self) {
        println!("{} ♫", self);
    }
}

fn main() {
    let line = "The slithy structs did gyre and gimble the namespace";

    // Build a trait object holding a String.
    // This requires String to implement MyTrait and std::clone::Clone.
    let x: Box<dyn MyTrait> = Box::new(String::from(line));

    x.recite();

    // The type of x2 is a Box<dyn MyTrait> cloned from x.
    let x2 = dyn_clone::clone_box(&*x);

    x2.recite();
}
```

This crate includes a macro for generating the implementation `impl
std::clone::Clone for Box<dyn MyTrait>` in terms of `dyn_clone::clone_box`:

```rust
// As before.
trait MyTrait: DynClone {
    /* ... */
}

dyn_clone::clone_trait_object!(MyTrait);

// Now data structures containing Box<dyn MyTrait> can derive Clone:
#[derive(Clone)]
struct Container {
    trait_object: Box<dyn MyTrait>,
}
```


#### License

Licensed under either of Apache License, Version
2.0 or MIT license at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
be dual licensed as above, without any additional terms or conditions.

