Hello,

Je débute en Rust et pour pratiquer, j'essaye de reproduire du code C++ en Rust. 

En ce moment, j'essaye de réécrire une liste chainée en m'inspirant de ce code :

C-Plus-Plus/data_structures/linked_list.cpp at master · TheAlgorithms/C-Plus-Plus · GitHub

J'ai en ce moment, une erreur que je ne comprends pas et que je n'arrive pas à résoudre.

error[E0594]: cannot assign to data in an `Rc`
  --> src/main.rs:46:21
   |
46 |                     last.succ = t.clone();
   |                     ^^^^^^^^^ cannot assign
   |
   = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Rc<Link>`

Voici le code :

use std::rc::Rc;


#[derive(Clone)]
struct Link {
    pvalue: i32,
    succ : Option<Rc<Link>>
}

struct List{
    first : Option<Rc<Link>>,
    last  : Option<Rc<Link>>
}

impl Link {
    fn new(value : i32) -> Link {
        Link{
            pvalue : value,
            succ : None,
        }
    }
}

impl List {
    fn new() -> List {
        List {
            first : Some(Rc::new(Link::new(0))),
            last : None
        }
    }
    fn is_empty(&self) -> bool {
        match &self.last {
            None => return true,
            Some(_value) => return false
        }
    }
    
    fn push_back(&mut self,new_elem : i32) {
        if self.is_empty() {
            self.push_front(new_elem);
        } 
        else {
            let t = Some(Rc::new(Link::new(new_elem)));
            match &mut self.last {
                Some(ref mut last) => {
                    last.succ = t.clone();
                    self.last = t.clone();
                },
                None => panic!("Sould not be null")
            }
        }
    }

    fn push_front(&mut self, new_elem : i32) {
        if self.is_empty() {
            match &mut self.first {
                Some(ref mut first) => {
                    first.succ = Some(Rc::new(Link::new(new_elem)));
                    self.last = self.first.clone();
                },
                None => panic!("Sould not be null")
            }
        } 
        else {
            let mut t : Link;
            t = Link::new(new_elem);
            match &mut self.first {
                Some(ref mut first) => {
                    t.succ = first.succ.clone();
                    first.succ = Some(Rc::new(t));
                },
                None => panic!("Sould not be null")
            }
        }
    }

    
    fn display(&self) {
        if self.is_empty() {
            println!("List is Empty!");
            return;
        }
        let mut t = self.first.clone();
        while t.as_ref().unwrap().succ.is_some() {
            let value = t.as_ref().unwrap().succ.clone().unwrap().pvalue;
            print!("{value} ");
            t = t.unwrap().succ.clone();
        }
        println!("");
    }
    
    
}

fn main() {
    let mut l : List;
    l = List::new();
    assert!(l.is_empty() == true);
  /*  for i in  0..10 {
        l.push_front(i);
    }
    assert!(l.is_empty() == false);*/
    for i in  0..10 {
        l.push_back(i);
    }
    assert!(l.is_empty() == false);
    l.display();
}

D'ailleurs si vous avez des remarques en dehors de cette erreur je suis preneur.

Merci!

last.succ = t.clone(); -> last.succ = Some(Rc::clone(t.unwrap()));