Rust Error E0735: Type Parameter Defaults and Self

Understanding Rust Error E0735

Rust error code E0735 occurs when type parameter defaults on structs, enums, or unions use the Self keyword. This is not allowed in Rust because it would create a cyclic reference, resulting in a type that is infinitely recursive and cannot be resolved by the compiler.

Erroneous code example:

#![allow(unused)]
fn main() {
    struct Foo<X = Box<Self>> {
        field1: Option<X>,
        field2: Option<X>,
    }
    // error: type parameters cannot use `Self` in their defaults.
}

Fixing Rust Error E0735

To fix this error, remove the use of Self from the type parameter default and replace it with a specific type or another compatible generic type. Here's an example of how you can correct the above erroneous code:

#![allow(unused)]
fn main() {
    struct Foo<X = Box<Inner>> {
        field1: Option<X>,
        field2: Option<X>,
    }

    struct Inner;
}

In this corrected example, we define an Inner struct and use it as the default type for the type parameter X in the Foo struct. This resolves the issue and allows the code to compile successfully.

Alternative Solutions

Another way to address this issue is to use the associated type pattern in a trait to achieve a similar outcome. For example:

trait Bar {
    type X;
    fn new(value1: Option<Self::X>, value2: Option<Self::X>) -> Self;
}

struct Foo {
    field1: Option<Box<Inner>>,
    field2: Option<Box<Inner>>,
}

impl Bar for Foo {
    type X = Box<Inner>;

    fn new(value1: Option<Self::X>, value2: Option<Self::X>) -> Self {
        Foo { field1: value1, field2: value2 }
    }
}

struct Inner;

In this alternative solution, we define a Bar trait with an associated type X, and a constructor function new. We then implement the Bar trait for the Foo struct and provide the desired default behavior.