error[E0308]: mismatched types --> $DIR/compatible-variants.rs:13:5 | LL | fn a() -> Option<()> { | ---------- expected `Option<()>` because of return type LL | / while false { LL | | LL | | f(); LL | | } | |_____^ expected `Option<()>`, found `()` | = note: expected enum `Option<()>` found unit type `()` = note: `while` loops evaluate to unit type `()` help: try adding an expression at the end of the block | LL ~ } LL + None | LL ~ } LL + Some(()) | error[E0308]: mismatched types --> $DIR/compatible-variants.rs:21:5 | LL | fn b() -> Result<(), ()> { | -------------- expected `Result<(), ()>` because of return type LL | f() | ^^^ expected `Result<(), ()>`, found `()` | = note: expected enum `Result<(), ()>` found unit type `()` help: try adding an expression at the end of the block | LL ~ f(); LL + Ok(()) | error[E0308]: mismatched types --> $DIR/compatible-variants.rs:27:5 | LL | fn c() -> Option<()> { | ---------- expected `Option<()>` because of return type LL | / for _ in [1, 2] { LL | | LL | | f(); LL | | } | |_____^ expected `Option<()>`, found `()` | = note: expected enum `Option<()>` found unit type `()` = note: `for` loops evaluate to unit type `()` help: try adding an expression at the end of the block | LL ~ } LL + None | LL ~ } LL + Some(()) | error[E0308]: `?` operator has incompatible types --> $DIR/compatible-variants.rs:35:5 | LL | fn d() -> Option<()> { | ---------- expected `Option<()>` because of return type LL | c()? | ^^^^ expected `Option<()>`, found `()` | = note: `?` operator cannot convert from `()` to `Option<()>` = note: expected enum `Option<()>` found unit type `()` help: try removing this `?` | LL - c()? LL + c() | help: try adding an expression at the end of the block | LL ~ c()?; LL + None | LL ~ c()?; LL + Some(()) | error[E0308]: mismatched types --> $DIR/compatible-variants.rs:42:25 | LL | let _: Option<()> = while false {}; | ---------- ^^^^^^^^^^^^^^ expected `Option<()>`, found `()` | | | expected due to this | = note: expected enum `Option<()>` found unit type `()` help: try wrapping the expression in `Some` | LL | let _: Option<()> = Some(while false {}); | +++++ + error[E0308]: mismatched types --> $DIR/compatible-variants.rs:46:9 | LL | while false {} | ^^^^^^^^^^^^^^ expected `Option<()>`, found `()` | = note: expected enum `Option<()>` found unit type `()` = note: `while` loops evaluate to unit type `()` help: try adding an expression at the end of the block | LL ~ while false {} LL + None | LL ~ while false {} LL + Some(()) | error[E0308]: mismatched types --> $DIR/compatible-variants.rs:50:31 | LL | let _: Result = 1; | ---------------- ^ expected `Result`, found integer | | | expected due to this | = note: expected enum `Result` found type `{integer}` help: try wrapping the expression in a variant of `Result` | LL | let _: Result = Ok(1); | +++ + LL | let _: Result = Err(1); | ++++ + error[E0308]: mismatched types --> $DIR/compatible-variants.rs:53:26 | LL | let _: Option = 1; | ----------- ^ expected `Option`, found integer | | | expected due to this | = note: expected enum `Option` found type `{integer}` help: try wrapping the expression in `Some` | LL | let _: Option = Some(1); | +++++ + error[E0308]: mismatched types --> $DIR/compatible-variants.rs:56:28 | LL | let _: Hey = 1; | ------------- ^ expected `Hey`, found integer | | | expected due to this | = note: expected enum `Hey` found type `{integer}` help: try wrapping the expression in a variant of `Hey` | LL | let _: Hey = Hey::A(1); | +++++++ + LL | let _: Hey = Hey::B(1); | +++++++ + error[E0308]: mismatched types --> $DIR/compatible-variants.rs:59:29 | LL | let _: Hey = false; | -------------- ^^^^^ expected `Hey`, found `bool` | | | expected due to this | = note: expected enum `Hey` found type `bool` help: try wrapping the expression in `Hey::B` | LL | let _: Hey = Hey::B(false); | +++++++ + error[E0308]: mismatched types --> $DIR/compatible-variants.rs:63:19 | LL | let _ = Foo { bar }; | ^^^ expected `Option`, found `i32` | = note: expected enum `Option` found type `i32` help: try wrapping the expression in `Some` | LL | let _ = Foo { bar: Some(bar) }; | ++++++++++ + error[E0308]: mismatched types --> $DIR/compatible-variants.rs:80:16 | LL | let a: A = B::Fst; | - ^^^^^^ expected `A`, found `B` | | | expected due to this | help: try wrapping the expression in `A::B` | LL | let a: A = A::B { b: B::Fst }; | +++++++++ + error[E0308]: mismatched types --> $DIR/compatible-variants.rs:86:17 | LL | let a: A2 = B::Fst; | -- ^^^^^^ expected `A2`, found `B` | | | expected due to this | help: try wrapping the expression in `A2` | LL | let a: A2 = A2(B::Fst); | +++ + error: aborting due to 13 previous errors For more information about this error, try `rustc --explain E0308`.