# Function signature when size of returned array can be computed at compile time

Hey everyone!
I am currently stuck at a problem I can't quite wrap my head around.
I have this function

``````fn seal(&self, m: &[u8], ad: &[u8], nonce: &[u8; 8]) -> [u8; ???]
``````

and I known 100% that the returned array will always be of size `m.len() + 16`.
This should be something that is computable at compile time, is it now? So how can I express this in the return value?

It's not, since `m.len()` is not computable at compile-time.

But it is, or not? I can provide e.g. `[0u8; 16]` as `m`, whose size is known at compile time.

Or you can provide `vec.as_slice()`, whose size isn't. Current signature doesn't give the information on `m.len()` (and in general, it can't - Rust is not dependently-typed).

1 Like

You would need something like :

``````// on nightly
#![feature(generic_const_exprs)]

fn seal<const N: usize>(&self, m: &[u8; N], ad: &[u8], nonce: &[u8; 8]) -> [u8; N + 16]
^^ note I'm adding this information for the compiler,
you won't be able to pass any slice but
only references to fixed sized arrays here
``````

Ahh yes this is exactly what I was looking for. Thank you very much!