Understanding Rust Error E0178: Ambiguous Use of + Type Operator

Rust Error E0178

This error occurs when the + type operator is used in an ambiguous context. It means that the low precedence of the + operator is causing a conflict with other types. To fix the issue, you may need to add parentheses to clarify the precedence. Here's the erroneous code example provided in the official Rust documentation:

#![allow(unused)]
fn main() {
trait Foo {}

struct Bar<'a> {
    x: &'a Foo + 'a,     // error!
    y: &'a mut Foo + 'a, // error!
    z: fn() -> Foo + 'a, // error!
}
}

Clarifying the Precedence with Parentheses

To resolve the error, you can add parentheses to make the precedence clear. Here's the corrected code example:

#![allow(unused)]
fn main() {
trait Foo {}

struct Bar<'a> {
    x: &'a (Foo + 'a),     // ok!
    y: &'a mut (Foo + 'a), // ok!
    z: fn() -> (Foo + 'a), // ok!
}
}

Detailed Explanation

In the original erroneous code, the issue lies in the structure definition of Bar, where the + type operator is used without parentheses. This causes ambiguity in the following three lines:

x: &'a Foo + 'a,
y: &'a mut Foo + 'a,
z: fn() -> Foo + 'a,

To understand the issue better, it's crucial to know that the + type operator has a lower precedence compared to other type operators. It's quite common to encounter error E0178 when you inadvertently use the + operator without specifying proper precedence.

To fix Rust error E0178, simply add parentheses to make the order of operation clear, as shown in the corrected code.

Further Reading

You can find more details regarding this error and related language semantics in the Rust Language Reference and RFC 438.