Default generic parameter

Question

I have a struct that we can construct with the builder pattern because there are some Optional fields.

If I use the builder functions to specify these optional fields, I don't have to specify the generic parameters.

But if I don't call these functions, I need to specify the generic parameters.

Here is an example:

use Structs::*;

struct Struct<T, F: Fn(T)> {
    func: Option<F>,
    value: T,
}

enum Structs<T, F: Fn(T)> {
    Struct1(T),
    Struct2(T, F),
}

impl<T, F: Fn(T)> Struct<T, F> {
    fn new(value: T) -> Struct<T, F> {
        Struct {
            func: None,
            value: value,
        }
    }

    fn build(self) -> Structs<T, F> {
        if let Some(func) = self.func {
            Struct2(self.value, func)
        }
        else {
            Struct1(self.value)
        }
    }

    fn func(mut self, func: F) -> Struct<T, F> {
        self.func = Some(func);
        self
    }
}

fn main() {
    let _strct = Struct::new(42)
        .func(|n| { println!("{}", n); })
        .build();

    //let _strct = Struct::new(42).build(); // Does not compile.
    let _strct = Struct::<_, &Fn(_)>::new(42).build();
}

I would like to omit the type annotation when the optional fields are not set, like so:

let _strct = Struct::new(42).build();

It should be specified that the F type depends on T.

I tried specifying a default type parameter as such:

impl<T, F: Fn(T) = Box<Fn(T)>> Struct<T, F> {

but it does not solve the issue.

So how can I avoid having to specify the type parameters in the Struct::new() call?

If it is not possible to avoid this, is there any alternatives to the builder pattern that would allow me to omit the type annotation?

Answer 1

Following Francis Gagné's clever solution, here's a similar idea that can work on stable Rust:

struct Struct<T, F: Fn(T)> {
    func: Option<F>,
    value: T,
}

enum Structs<T, F: Fn(T)> {
    Struct1(T),
    Struct2(T, F),
}

impl<T> Struct<T, fn(T)> {
    fn new(value: T) -> Struct<T, fn(T)> {
        Struct {
            func: None,
            value: value,
        }
    }
}

impl<T, F: Fn(T)> Struct<T, F> {
    fn func<F2: Fn(T)>(self, func: F2) -> Struct<T, F2> {
        Struct {
            func: Some(func),
            value: self.value,
        }
    }

    fn build(self) -> Structs<T, F> {
        use Structs::*;

        if let Some(func) = self.func {
            Struct2(self.value, func)
        } else {
            Struct1(self.value)
        }
    }
}

fn main() {
    let _strct = Struct::new(42)
        .func(|n| {
            println!("{}", n);
        })
        .build();

    let _strct = Struct::new(42).build();
}

Instead of a clear Void type, we simply say that we return a struct that would be parameterized for a function pointer. You could likewise specify a reference trait object:

impl<T> Struct<T, &'static Fn(T)> {
    fn new(value: T) -> Struct<T, &'static Fn(T)> {

Answering my own question from a comment:

If you don't specify a concrete type for T or F, then how much space should the Rust compiler allocate to store Struct?

The size of a fn() is 8 bytes on a 64-bit machine, leading to a total of 16 bytes for the entire structure:

std::mem::size_of::<fn()>();
std::mem::size_of_val(&strct);

However, when you give it a concrete callback, the structure only takes 8 bytes! That's because the type will be monomorphized for the callback, which needs no state and can basically be inlined.

Francis Gagné's solution only requires 8 bytes in each case, as the Void type has a size of zero!