shall we establish a new size bound for Value, may be constrainting to 24 bytes in total, and so any type making it larger should be boxed?

edit: I think reasonable max size is probably 32 bytes, then we can hold a Vec<T> or String, which are 24 bytes themselves.

We can just assert the current size for now. If a new variant appears, makes the enum larger and breaks the assertion, then we can benchmark and decide whether we need to box that new variant

I'd probably add this:

https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=d65d5efec03c1751464e479bb0541f21

const _: () = {
    check_value_size();
};

const fn check_value_size() {
    if std::mem::size_of::<Value>() > 32 {
        panic!("the size of Value shouldn't be greater than 32 bytes")
    }
}

I'd also add a comment right there, next to the assertion. To document our approach and the existence of the benchmark

Based on the benchmark results, I didn't see any performance impact from the size of Value (24 vs 40). I think the heap allocation would have a larger performance overhead.

@Huliiiiii I agree with you. object in heap is almost always worse than on stack. but I think we should put a guard in place to prevent it growing unchecked.

I'll probably make some small tweaks