Rust has a Clone trait which provides the .clone() method, which isn’t a shallow clone or a deep clone, due to Rust’s ownership model—the terms “shallow clone” and “deep clone” actually don’t make sense in Rust.

For completeness, I must mention that when you get to types like Rc<T>, deep cloning becomes a meaningful operation, but even there it’s not exposed as a deep clone method, but rather via make_mut (https://doc.rust-lang.org/std/rc/struct.Rc.html#method.make_...) which skips the deep part of cloning if there are no other references to the inner value.

Rust’s ownership model is absolutely delightful to work with. I miss it all the time when working in Python or JavaScript, and encounter and write bugs that would have been structurally impossible in Rust from time to time—to say nothing of inefficiencies that would have been either inexpressible or unreasonable in Rust.

Python: https://docs.python.org/3.7/library/copy.html#copy.deepcopy

Rust's `Clone` trait is deep by default, except for

- Types with shared semantics (e.g. Rc<T>, Arc<T>), or holding onto these internally

- Types holding borrowed references (these will still reference the same data).

C++'s copy constructors are too, but there are more caveats, although they're similar in principal to Rust's caveats.

Most(all?) functional programming languages.