Reducing boilerplates via template types and layout forwards

[RaitoBezarius]

In idiomatic Rust code, it's frequent to have a dozens of monomorphization of types which layouts are very much like max(T, E).

Template types allows to set methods once, but still requires manual declaration of instantiations.

What if we could:

• declare #layout_conservative_like(T1, T2, …, TN) on a template type to define a generic layout
• not have to manually declare instantiations anymore

Let zngur encounter an uninstantiated type for which a template type exist with a generic layout and instantiate on the fly.
This wouldn't solve all boilerplate cases but this would probably pave the way to reduce it.

WDYT?

[hkalbasi]

I'm not sure that I understand. You can use a #layout_conservative on a generic type, assuming that you can accept some memory waste (then provide empty instantiations, which is some boilerplate, but you need to mention types anyway). Do you need something more?

[RaitoBezarius]

Yes, I'd like to get rid of the empty instantiations and I don't want to provide static conservative waste, I want to forward the layout calculations to base types and have all the composite types reuse it cleverly.

(Result<T, E> forwards to max(T, E); Futures forwards to ..., etc, etc, etc.)

[pennae]

you'd also have to some kind of expression support. #layout_conservative_like(T1, T2, …, TN) will not work in all cases, eg when constructing layouts for enum types. for those you'd somehow need to ensure space for the discriminator exists as well

[hkalbasi]

Ah I see, you want some type calculation operators. The thing is that max(T, E) is not correct for Result<T, E>, you need something like max(size(T), size(E)) + max(align(T), align(E)). Then there is problem of niches and similar things. I agree that we eventually need some type calculation language, but it needs a design to cover most common cases.

[RaitoBezarius]

Agreed.