How to clone a Box when I keep getting "no method named clone"?

Question

I want to clone head which is a Box<Node<T>>:

let mut node = Some((*head).clone());

Here is the full code (playground):

use std::boxed::Box;

pub struct List<T> {
    pub head: Option<Box<Node<T>>>,
    pub size: u64,
}

impl<T> List<T> {
    pub fn new() -> List<T> {
        return List {
            head: Option::None,
            size: 0,
        };
    }

    pub fn push_back(&mut self, data: T) {
        match &self.head {
            Some(head) => {
                let mut node = Some((*head).clone());
                while (*(node).unwrap()).next.is_some() {
                    node = (*node.unwrap()).next;
                }
                node.unwrap().next = Some(Box::new(Node::new(data)));
            }
            None => {
                self.head = Some(Box::new(Node::new(data)));
            }
        }
    }
}

#[derive(Clone)]
pub struct Node<T> {
    pub next: Option<Box<Node<T>>>,
    pub value: T,
}

impl<T> Node<T> {
    pub fn new(v: T) -> Node<T> {
        Node {
            next: Option::None,
            value: v,
        }
    }
}

The compiler keeps saying the method clone exists but the following trait bounds were not satisfied:

error[E0599]: no method named `clone` found for type `std::boxed::Box<Node<T>>` in the current scope
  --> src/lib.rs:19:45
   |
19 |                 let mut node = Some((*head).clone());
   |                                             ^^^^^
   |
   = note: the method `clone` exists but the following trait bounds were not satisfied:
           `Node<T> : std::clone::Clone`
           `std::boxed::Box<Node<T>> : std::clone::Clone`
   = help: items from traits can only be used if the trait is implemented and in scope
   = note: the following trait defines an item `clone`, perhaps you need to implement it:
           candidate #1: `std::clone::Clone`

I tried to add #[derive(Clone)] but it still doesn't work:

#[derive(Clone)]
pub struct Node<T> {
    pub next: Option<Box<Node<T>>>,
    pub value: T
}

How can I do this?

Answer 1

A reproduction of the error:

#[derive(Clone)]
pub struct Node<T> {
    pub next: Option<Box<Node<T>>>,
    pub value: T,
}

fn thing<T>(node: Node<T>) {
    node.clone();
}

error[E0599]: no method named `clone` found for type `Node<T>` in the current scope
 --> src/lib.rs:8:10
  |
2 | pub struct Node<T> {
  | ------------------ method `clone` not found for this
...
8 |     node.clone();
  |          ^^^^^
  |
  = note: the method `clone` exists but the following trait bounds were not satisfied:
          `Node<T> : std::clone::Clone`
  = help: items from traits can only be used if the trait is implemented and in scope
  = note: the following trait defines an item `clone`, perhaps you need to implement it:
          candidate #1: `std::clone::Clone`

You need to add a trait bound that says that T implements Clone:

fn thing<T>(node: Node<T>)
where
    T: Clone,
{
    node.clone();
}

See also:

• Deriving a trait results in unexpected compiler error, but the manual implementation works

---

Your code has numerous non-idiomatic aspects:

• unneeded import of std::boxed::Box
• unneeded unwraps
• unneeded dereferences.

You don't even need clone here, and it's probably incorrect to use it. I'd write:

pub fn push_back(&mut self, data: T)
where
    T: Clone,
{
    let spot = match &mut self.head {
        Some(head) => {
            let mut node = &mut head.next;
            while let Some(n) = node {
                node = &mut n.next;
            }
            node
        }
        None => &mut self.head,
    };

    *spot = Some(Box::new(Node::new(data)));
}

See also:

• Adding an append method to a singly linked list