Is it possible to avoid boxing a FnOnce closure to hold it briefly in a builder struct?

help
1

In the code below, I'd like to avoid needing a short-lived heap allocation for payload_generator, but I cannot find an alternative that compiles. Option<dyn FnOnce(...)> doesn't work at all because dyn FnOnce isn't Sized. Option<&'a dyn FnOnce(...)> lets me put the closure into the builder (if I write &|v| ... in the caller of payload() and adjust payload's signature to match) but then it won't let me call the closure because it can't be moved out from behind a shared reference.

The closure in example doesn't need to be addressed as FnOnce, but in the real program this has been cut down from, some of them do.

Open to any suggestion that keeps the API of Builder essentially as is (e.g. I don't want to make payload_generator an argument to build, because in the real program it would almost always be passed as None, defeating the point of a builder struct).

struct Builder<'a> {
    // other fields
    
    // // E0277 size for values of type `...` cannot be known at compilation time
    //payload_generator: Option<dyn FnOnce(&mut Vec<u8>) + 'a>,

    // // E0507 cannot move out of `*gen` which is behind a shared ref (build())
    //payload_generator: Option<&'a dyn FnOnce(&mut Vec<u8>)>,
    
    payload_generator: Option<Box<dyn FnOnce(&mut Vec<u8>) + 'a>>,
}

impl<'a> Builder<'a> {
    pub fn new() -> Self {
        Self { payload_generator: None }
    }
    
    pub fn payload(mut self, gen: impl FnOnce(&mut Vec<u8>) + 'a) -> Self {
        self.payload_generator = Some(Box::new(gen));
        self
    }
    
    pub fn build(mut self) -> Vec<u8> {
        match self.payload_generator.take() {
            None => vec![],
            Some(gen) => {
                let mut v: Vec<u8> = Vec::new();
                gen(&mut v);
                v
            }
        }
    }
}

pub fn example(s: &str) -> Vec<u8> {
    Builder::new()
    .payload(|v| v.extend_from_slice(s.as_bytes()))
    .build()
}

(Playground)

2

If you closure does not have any state, you can use function pointers (i.e. fn(&mut Vec<u8>)). But if it does, your only choice is to make the builder struct generic over closure type:

struct Builder<F: FnOnce(&mut Vec<u8>)> {
    payload_generator: Option<F>,
}

Think about the closure as any other generic type. The struct field stores the closure state with its size dependent on the closure type. Technically, we could've used unsized types, but their support in Rust is rudimentary, to say the least.

Unfortunately, this code has an issue of not being able to name the "default" closure type which will be used for when the field has value of None. Manual implementation of FnOnce unfortunately is currently unstable.

3

Yeah, unfortunately some of the closures do have state.

your only choice is to make the builder struct generic over closure type ... issue of not being able to name the "default" closure type

I tried that too and tripped over the problem you mention, and also that it means .payload() takes a value of type Builder<F1> and returns a value of type Builder<F2> ... which, now I think about it, might actually offer a way out. Lemme go tinker a bit more...

5

You can use fn(&mut Vec<u8>) as the default type.

impl Builder<fn(&mut Vec<u8>)> {
    pub fn new() -> Self {
        Self { payload_generator: None }
    }
}

This is a great way to make builders more flexible and statically checked. When used to add more checking (e.g. that the builder isn't missing any required items) it is called type-state.

4 Likes
6

Ah, true. I quickly tried it in playground, but it did not work (probably because of my mistake) and I quickly gave up, but your snippet works.

7

Aha, that was the missing piece I needed. I'd gotten it working with two different concrete types, Builder and BuilderWithPayload<F>, but that was going to require me to duplicate all the unrelated methods, and then I thought of having Builder::new somehow return Builder<F> where the concrete F is a no-op function? but I was stuck on impl<F> Builder<F> requiring the caller of Builder::new to say what F is.

With a second impl block just for the new, specifying your suggested default type, this works. (I added another field to make it more realistic.)

fn pgen_noop(_: &mut Vec<u8>) {}

struct Builder<'a, F: FnOnce(&mut Vec<u8>)> {
    leader: &'a str,
    payload_generator: F,
    // more stuff in real program
}

impl<'a> Builder<'a, fn(&mut Vec<u8>)> {
    pub fn new(leader: &'a str) -> Self {
        Self {
            leader,
            payload_generator: pgen_noop,
        }
    }
}

impl<'a, F: FnOnce(&mut Vec<u8>)> Builder<'a, F> {
    pub fn payload<G: FnOnce(&mut Vec<u8>)>(self, gen: G) -> Builder<'a, G> {
        Builder {
            leader: self.leader,
            payload_generator: gen,
        }
    }

    // more methods in real program
 
    pub fn build(self) -> Vec<u8> {
        let mut v = Vec::new();
        v.extend_from_slice(self.leader.as_bytes());
        (self.payload_generator)(&mut v);
        v
    }
}

pub fn example1() -> Vec<u8> {
    Builder::new("leader1")
    .build()
}

pub fn example2(s: &str) -> Vec<u8> {
    Builder::new("leader2: ")
    .payload(|v| v.extend_from_slice(s.as_bytes()))
    .build()
}
8

I think I'd prefer the fn(...) solution as well, but I was curious and came up with this idea of splitting the impl without the downsides of duplicating the methods (not sure if it's fully functional though) Rust Playground:

trait PayloadGen {
    fn gen(self, v: Vec<u8>) -> Vec<u8>;
}

impl PayloadGen for () {
    fn gen(self, mut v: Vec<u8>) -> Vec<u8> {
        vec![]
    }
}

impl<T: for<'a> FnOnce(&'a mut Vec<u8>)> PayloadGen for T {
    fn gen(self, mut v: Vec<u8>) -> Vec<u8> {
        self(&mut v);
        v
    }
}

struct Builder<'a, PG: PayloadGen = ()> {
    leader: &'a str,
    payload_generator: PG,
}

impl<'a> Builder<'a> {
    pub fn new() -> Self {
        Self {
            leader: "",
            payload_generator: (),
        }
    }
}

impl<'a, PG: PayloadGen> Builder<'a, PG> {
    pub fn payload<F: FnOnce(&mut Vec<u8>) + PayloadGen>(self, gen: F) -> Builder<'a, F> {
        let builder = Builder::<'a, F> {
            leader: self.leader,
            payload_generator: gen,
            // ... : self...
        };
        builder
    }

    pub fn with_leader(mut self, leader: &'a str) -> Self {
        self.leader = leader;
        self
    }

    pub fn build(mut self) -> Vec<u8> {
        self.payload_generator.gen(Vec::new())
    }
}

pub fn example(s: &str) -> Vec<u8> {
    Builder::new()
        .payload(|v| v.extend_from_slice(s.as_bytes()))
        .with_leader(s)
        .build()
}
1 Like