I have a struct that has a field where the type is generic, but to create new records of this struct does not let me copy the generic types into rust

use std::fmt::Display;
use std::fmt::Formatter;
use std::fmt::Result;

pub struct LinkedList<T> {
    head: Option<Box<Node<T>>>,
    lenght: u32
}
impl<T: Display> LinkedList<T> {
    pub fn new() -> LinkedList<T> {
        LinkedList { head: None, lenght: 0 }
    }

    pub fn lenght(&self) -> u32 {
        return self.lenght;
    }

    pub fn add(&mut self,value: T) {

        match &self.head {
            Some(p) => {
                self.head = Node::new(value, Some(*p));
            },
            None => self.head = Node::new(value, None),
        }

        self.lenght += 1;
    }
}


struct Node<T> {
    value: T,
    next: Option<Box<Node<T>>>
}
impl<T> Node<T> {
    fn new(value: T,next: Option<Box<Node<T>>>) -> Option<Box<Node<T>>> {
        Some(Box::new(Node { value: value,next: next}))
    }

    fn function(pointer: &Box<Node<T>>) -> Option<Box<Node<T>>> {
        let value = pointer.value;
        let next = pointer.next;
        Node::new(value, next)
    }
}
impl<T: Display> Display for Node<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        write!(f,"{}",self.value)
    }
}

fn main() {
    let mut list: LinkedList<u32> = LinkedList::new();
    list.add(5);
    list.add(7);
    list.add(18);
}

I am learning rust and so I am trying to implement LinkedLists as an exercise to understand how the language works, but I am stuck.

I cannot add the elements because I cannot enter the current head for the new element as the successor

I think I'm having problems with the ownership rules, I've tried to read the documentation, but I don't understand how to overcome this problem

I would like somehow once I add an item to the list to have the successor be the current head and the head swapped with the new one

Linked list are not particularly easy or performant in Rust, that has become some kind of meme.

That said your LinkedList::add() function is easy to fix. The issue is that you are taking self as a mutable reference, so everything inside is borrowed, but you need ownership of the value to be able to insert it into the tail of the newly created node. That is what the compiler is probably trying to tell you.

Since you cannot own a borrowed value, the solution is to steal it, that is replace it with a dummy value. Fortunately your value is inside an Option so there is a function for that: Option::take():

    pub fn add(&mut self, value: T) {
match self.head.take() {
Some(p) => {
self.head = Node::new(value, Some(p));
},
None => self.head = Node::new(value, None),
}
self.lenght += 1;
}

There is still an error in Node::function() but I don't know that that is supposed to do. Also there are a few non-idiomatic Rust here and there, such as the requirement for : Display when no Display is being used, or returning Option<Node>() from a Node::new(), but nothing else that fails the compilation.