if b { x } else { y } requires identical types for x and y

[ben0x539]

This fails:

fn print(b: bool, s1: &str, s2: &str) {
    io::println(if b { s1 } else { s2 });
}

foo.rs:2:33: 2:39 error: mismatched types: expected `&/str` but found `&/str` (lifetime mismatch)
foo.rs:2     io::println(if b { s1 } else { s2 });
                                          ^~~~~~
foo.rs:1:38: 3:1 note: the anonymous lifetime #1 defined on the block at 1:38...
[...]
foo.rs:1:38: 3:1 note: ...does not necessarily outlive the anonymous lifetime #2 defined on the block at 1:38
[...]

while this works (giving the two borrowed pointers the same lifetime):

fn print(b: bool, s1: &r/str, s2: &r/str) {
    io::println(if b { s1 } else { s2 });
}

as does this (not returning the pointers through if {} else {}):

fn print(b: bool, s1: &str, s2: &str) {
    let mut s: &str;
    if b { s = s1; } else { s = s2; }
    io::println(s);
}

@nikomatsakis suggested the first example should work and that the type checker
should be content if the types of the two arms of the if{}else{} expression
have a common supertype, rather than requiring them to be the same.

[catamorphism]

I agree -- the type of the if should be the most specific supertype (LUB) of the types of the consequent and alternative.

[bblum]

I believe this is the idea of "intersection types".

I remember discussing this with another PL researcher at CMU during another project of mine, especially w.r.t. the case of the intersected type being a function (in which the subtyping has to contravary in the argument). Our conclusion was that simply switching between intersection and union isn't actually sound (unless the subtyping relation is a total ordering, which in rust it's not). I haven't seen any literature on the subject but could maybe remember the counterexample if I had to.

[catamorphism]

Maybe I'm missing something, but I don't think this requires intersection types, just subtyping? I don't think Rust allows subtyping on function types anyway, though I could be wrong!

[nikomatsakis]

This is a simple matter of subtyping and yes Rust does support subtyping on function types.

[catamorphism]

Nominating for milestone 1, well-defined

[graydon]

Updated example, still fails:

fn print<'a,'b>(b: bool, s1: &'a str, s2: &'b str) {
    println(if b { s1 } else { s2 });
}

fn main() {}

@pcwalton suggests that @nikomatsakis is rewriting the inference pass to use subtyping in even-fewer places than currently used, so this is probably never going to work. Paging @nikomatsakis for confirmation.

[graydon]

accepted for well-defined milestone

[nikomatsakis]

Couple of things:

1. I changed the type rule for if in the code to compute the type of the if as the LUB of the then/else types. This is why the first example works.
2. I ... don't know why the second example fails. That seems like a bug.
3. This is independent from how we do inference.

[nikomatsakis]

@graydon for me this example type checks:

fn print<'a,'b>(b: bool, s1: &'a str, s2: &'b str) {
    println(if b { s1 } else { s2 });
}

fn main() {}

[alexcrichton]

This appears to have been fixed (both cases in the original code). Including a test in #8485