Compile const generics as arguments when optimized for size

pascaldekloe · September 6, 2025, 12:07pm

The compiler could treat const generics as function arguments behind the scenes when in "z" optimization. E.g., fn f<A: const u8>(x: f32) could be read as fn f(x: f32, A: u8) instead. The idea is to have less logic duplication in the resulting bytecode.

SkiFire13 · September 6, 2025, 3:51pm

How would something like this work?

fn f<const A: usize>() -> TypeId {
    TypeId::of::<[u8; A]>()
}

// becomes

fn f(A: usize) -> TypeId {
    // ???
}

scottmcm · September 6, 2025, 5:55pm

This is polymorphization; see previous conversations.

For now you need to do it by hand, since we don't have a pass for it. That applies both to type parameters

github.com/rust-lang/rust

library/std/src/fs.rs

6d5caf3a4


      
          pub fn read<P: AsRef<Path>>(path: P) -> io::Result<Vec<u8>> {
              fn inner(path: &Path) -> io::Result<Vec<u8>> {
                  let mut file = File::open(path)?;
                  let size = file.metadata().map(|m| usize::try_from(m.len()).unwrap_or(usize::MAX)).ok();
                  let mut bytes = Vec::try_with_capacity(size.unwrap_or(0))?;
                  io::default_read_to_end(&mut file, &mut bytes, size)?;
                  Ok(bytes)
              }
              inner(path.as_ref())
          }

and to const parameters

github.com/rust-lang/rust

library/core/src/array/mod.rs

6d5caf3a4


      
          /// Version of [`try_from_fn`] using a passed-in slice in order to avoid
          /// needing to monomorphize for every array length.
          ///
          /// This takes a generator rather than an iterator so that *at the type level*
          /// it never needs to worry about running out of items.  When combined with
          /// an infallible `Try` type, that means the loop canonicalizes easily, allowing
          /// it to optimize well.
          ///
          /// It would be *possible* to unify this and [`iter_next_chunk_erased`] into one
          /// function that does the union of both things, but last time it was that way
          /// it resulted in poor codegen from the "are there enough source items?" checks
          /// not optimizing away.  So if you give it a shot, make sure to watch what
          /// happens in the codegen tests.
          #[inline]
          fn try_from_fn_erased<T, R>(
              buffer: &mut [MaybeUninit<T>],
              mut generator: impl FnMut(usize) -> R,
          ) -> ControlFlow<R::Residual>
          where
              R: Try<Output = T>,

This file has been truncated. show original

But of course remember that this doing good things depends on really smart inlining -- after all, you don't want [u8; N]::eq going through memcpy, since just comparing i32s directly (with correct alignment handling) is much smaller in the code as well as faster, so polymorphizing doesn't actually always improve code size.

Topic		Replies	Views
Phantom const generics?	4	2443	September 11, 2018
Allow const generics in function constants	14	927	October 11, 2025
Allow Self::N in Array Lengths language design	3	351	September 11, 2025
pre-RFC `const` function arguments language design	99	10239	May 5, 2021
One usage pattern of const generics	0	1151	November 14, 2017

Compile const generics as arguments when optimized for size

Related topics