• Start Date: 2015-2-3
• RFC PR: rust-lang/rfcs#803
• Rust Issue: rust-lang/rust#23416
• Feature: ascription

Summary

Add type ascription to expressions.

Type ascription on expression

See also discussion on #354 and rust issue 10502.

Motivation

Type inference is imperfect. It is often useful to help type inference by annotating a sub-expression with a type. Currently, this is only possible by extracting

Typical use cases are where a function's return type is generic (e.g., collect) and where we want to force a coercion.

Type ascription can also be used for documentation

By allowing

Examples:

(Somewhat simplified examples, in these cases there are sometimes better solutions with the current syntax).

Generic return type:

// Current.
let z = if ... {
    let x: Vec<_> = foo.enumerate().collect();
    x
} else {
    ...
};

// With type ascription.
let z = if ... {
    foo.enumerate().collect(): Vec<_>
} else {
    ...
};

Coercion:

fn foo<T>(a: T, b: T) { ... }

// Current.
let x = [1u32, 2, 4];
let y = [3u32];
...
let x: &[_] = &x;
let y: &[_] = &y;
foo(x, y);

// With type ascription.
let x = [1u32, 2, 4];
let y = [3u32];
...
foo(x: &[_], y: &[_]);

Generic return type and coercion:

// Current.
let x: T = {
    let temp: U<_> = foo();
    temp
};

// With type ascription.
let x: T = foo(): U<_>;

Detailed design

設計（する）

The syntax

e ::= ... | e: T

where e is an expression

When type checking e: T, e must have type T. The must have type test includes implicit

At runtime, type ascription is a no-op, unless an implicit

@eddyb has implemented

This feature should land behind the ascription feature gate.

coercion and as vs :

A downside of type ascription is the overlap

To address this I propose two lints which check for: trivial casts and trivial numeric

A trivial cast is a cast x as T where x has type U and x can be implicitly

A trivial numeric

Like any lints, these can be customised per-crate by the programmer. Both lints are 'warn' by default.

Although this is a somewhat complex

Type ascription and temporaries

一時的な

There is an implementation

let mut foo: S = ...;
{
    let bar = &mut (foo: T);  // S <: T, no coercion required
    *bar = ... : T;
}
// Whoops, foo has type T, but the compiler thinks it has type S, where potentially T </: S

If we treat

The proposed solution is that type ascription expressions

&[mut] <expr>
let ref [mut] x = <expr>
match <expr> { .. ref [mut] x .. => { .. } .. }
<expr>.foo() // due to autoref
<expr> = ...;

Drawbacks

More syntax,

Interacts poorly with struct

If we introduce named arguments

Alternatives

We could do nothing and force programmers to use temporary

Rely on explicit

We could use a different symbol or keyword instead of :, e.g., is.

Unresolved questions

Is the suggested precedence

Should we remove integer

Style guidelines - should we recommend spacing or parenthesis to make type ascription syntax