Making Sized trait objects for a known set of structs implementing the trait

Is it possible to tell the compiler that I want a trait object that is Sized to accommodate a known set of structs implementing the Trait?

That is, if I have a public factory function for instantiating a Something and I have two different private somethings that implement the Something interface: FooSomething and BarSomething and I don't want heap allocation (i.e. I don't want the factory to return Box<Something>, can I make Something a trait and tell the compiler that the trait objects should be Sized to accommodate the larger of FooSomething and BarSomething?

Or do I need to make Something a struct that has an enum member that is a tagged union of FooSomething and BarSomething with manually-written dispatch that matches on the enum?

An enum is the easiest solution, yeah. (Some macro magic would allow you to avoid having to write match in every place that dispatches.)

Thanks. Ideally, there'd be a way to ask the compiler to generate the mechanic stuff instead of having to write it manually, using macros or using Python to generate Rust.

I think it should be possible to implement Something for the enum and avoid macros:

trait Something {
    fn calculte(&self) -> i32;

struct FooSomething;

impl Something for FooSomething {
    fn calculte(&self) -> i32 { 92 }

struct BarSomething;

impl Something for BarSomething {
    fn calculte(&self) -> i32 { 62 }

enum AnySomething {

impl Something for AnySomething {
    fn calculte(&self) -> i32 {
        match *self {
            AnySomething::Foo(ref foo) => foo.calculte(),
            AnySomething::Bar(ref bar) => bar.calculte()

This match was what I was hoping I could ask the compiler to generate for me instead of writing it in the source code.