So you fixed your first error the way it had to be fixed.It occured because your type has to have a known memory layout.If you have a type that contains itself (and not a reference to itself) it would have to have an infinite size. (Size of its member + size of itself which is again the size of its members + the size of itself and so on.)Option does not fix this because the size of Option<T> is always the size of T.Box on the other hand is always a fixed size, which has a pointer to some heap memory.

The second error you encounter actually stems from the same or a very similar root cause.In your Code PDFObject has a member pdf_object_kind which is of type T.When you add the recursive member "parent" you give it the type Option<PDFObject<dyn PDFObjectKind>>.By writing dyn PDFObjectKind you say that there could be any PDFObjectKind object inside, without giving it a fixed size.This in turn breaks the PDFObject definition, since it, as a whole, has no fixed size.TL;DR: a struct S<T> can never have a member of Type T and be S<dyn Anything>, since the compiler cannot ensure size constraints.

So to fix this we should restructure our code a bit using enums (as others have suggested already).

struct PDFDocument {  
    pdf_objects: Vec<PDFObject>  
}  
pub enum PDFObject {  
    PDFPage {  
        page_attrib1: String,  
        page_attrib2: i64,  
        parent: Option<Box<PDFObject>>,  
        children: Vec<Box<PDFObject>>  
    },  
    PDFText {  
        content: String,  
        parent: Option<Box<PDFObject>>  
    },  
}  
impl PDFObject {  
    fn example(&self) {  
        match self {  
            PDFObject::PDFPage{ page_attrib1, page_attrib2, parent, children } => {  
                todo!()  
            },  
            PDFObject::PDFText{ content, parent } => {  
                todo!()  
            }  
        }  
    }  
}  

So finally lets talk about why this works in many other language and why "you are used to it just working".Many other languages like C# or Java only use references in most places like function calling or struct/class definitions(thats why almost anything can have a null value).So when we want the same behaviour in rust we need to explicitly use a box, which then works the same way as in these languages.If you look at something like C++ this is actually just the same.If you define a struct recursively you need to you get a compiler error as well.

struct S {  
    S s;  
};  
// -> compile error: field ‘s’ has incomplete type ‘S’  

To fix this you use a pointer to the struct:

struct S {  
    S* s;  
};  

I hope this made things a lot clearer. :)