add turbofish-like syntax

[ghost]

Problem

In Rust, the "turbofish" syntax (::<>) allows users to explicitly specify generic type parameters in function calls. This feature has proven to be useful for disambiguating type inference in certain scenarios.

Happy Case

fn main() {
    let mut slice = [];
    slice = slice.push_back(1);
    slice = slice.push_back(2);
    let slice = slice.as_array::<2>();
}

Alternatives Considered

No response

Additional Context

No response

Would you like to submit a PR for this Issue?

No

Support Needs

No response

[Savio-Sou]

Converting to discussion for community chime in and votes.

[jfecher]

For now the workarounds are:

• If a function takes a parameter that uses the generic, you can add an explicit type annotation on the let binding for that argument.
• If a function returns a value which includes that generic, you can add a type annotation on a let binding for the return value.
• If none of the above apply - which sounds like your case - you can change the API of the function so that it accepts an empty struct which you can use to specify the size:

struct Size<N> {}

// before:
// fn my_fn<N>(){}
// after:
fn my_fn<N>(_size: Size<N>) {}

fn main() {
    let size: Size<10> = Size {};
    my_fn(size);
}

[LogvinovLeon]

Thanks! Will do that. My case is the fact the third.
Is there any workaround for having arithmetic on generic sizes?

[jfecher]

Unfortunately not, not allowing arithmetic on generic sizes is a somewhat fundamental limitation. You'd need fully dependent types or similar to be able to use those in generic code. Rust for example disallows them with the message:

error: generic parameters may not be used in const operations
 --> bar.rs:5:37
  |
5 | impl<const N: usize> Serialize<{2 * N + 1}> for SomeStruct<N> {
  |                                     ^ cannot perform const operation using `N`
  |
  = help: const parameters may only be used as standalone arguments, i.e. `N`

[LogvinovLeon]

Ok. What if I go the other direction and ask the user to provide me with both values but then assert them in my code?

fn fun<N, M>() -> [u8; M] {
...
assert(N + 1 == M);
...
}

Will that be feasible to implement?

[jfecher]

Yes, and it'd work with the current type system. From that example you'd need either turbofish once it's added or the Size<N> workaround mentioned above to specify N. Other than that though you can implement it today if wanted.