Why are type parameters are not allowed on this type?

Question

Attempting to compile the following,

fn do_it() -> Result<i32, u32> {
    Result::<i32, u32>::Ok(3)
}


fn main() {
    println!("{}", do_it());
}

results in:

./result_test.rs:2:14: 2:17 error: type parameters are not allowed on this type [E0109]
./result_test.rs:2     Result::<i32, u32>::Ok(3)
                                ^~~

Why are type parameters not allowed on this type?

This is a minimal example, my real-world example is a macro trying to return the following:

match $reader.$read_func() {
    Ok(n) => Result::<$read_type, LocalReadError>::Ok(n),
    Err(err) => Result::<$read_type, LocalReadError>::Err(
        LocalReadError::from(err)
    ),
}

$read_func is a function, $read_type is the return type of that function. (If I had a programmatic way to get that, I'd do so; I don't know how, so it's an arg…); as-is, I get the above error. If I remove the specification of the generic's parameters, type inteference complains that it can't figure out the type. (Because it ends up with Result<_, LocalReadError> in one branch of the match, and Result<$read_type, _> in the other? I'm not really sure. It says:

error: unable to infer enough type information about `_`; type annotations or generic parameter binding required [E0282]
    match $reader.$read_func() {
                  ^~~~~~~~~~~~

)

Note: The question about why type parameters are not allowed is answered below. Turns out this is not the cause of the "unable to infer enough type information". (read_func is a function, in my case, I'm passing a templated function, but forgetting the template arg, which can't be inferred.)

Answer 1

this is actually an inconsistency with enums that was discussed but not considered important enough to block 1.0.

The working syntax to specify types is Result::Ok::<i32, u32>(3).

An enum works like something between a type (that would go with the syntax you were trying to write) and a namespace (and namespaces don't accept type parameters).

To demonstrate how enums are like namespaces, you can write:

use std::result::Result::*;

fn main() {
    println!("{:?}", Ok::<i32, u32>(3));
}

This namespacing aspect is a desirable property of enums, but moving type parameters where one would intuitively think they should be would make this type of code very awkward to write.