existential type T<'a, 'b>; // = (&'a (), &'b ())
fn foo<'a, 'b>(x: &'a (), y: &'b ()) -> T<'a, 'b> { (x, y) }
fn foo<'a>(x: &'a (), y: &'a ()) -> T<'a, 'a> { (x, y) }
// ^^ this can't be a defining use
// because this could exist: (doesn't use 'b *at all*)
fn bar<'a, 'b>(x: &'a (), y: &'a ()) -> T<'a, 'b> { (x, x) }
// OR this could exist: (*does* use 'b)
fn bar<'a, 'b>(x: &'a (), y: &'a ()) -> T<'a, 'b> { (x, y) }
// does this concrete type use `'b` or not?
fn bar<'a, 'b: 'a>(...) -> T<'a, 'b> { (x, y) }
struct Foo<'a, 'b> {
..
}
impl<'a> Send for Foo<'a, 'a> {}
async fn make_foo(x: &'a u32, y; &'b u32) {
let x = Foo(x, y);
await!(some_thing());
existential type T<'a, 'b>; // = (&'a (), &'b ())
fn foo<'a, 'b>(x: &'a (), y: &'b ()) -> T<'a, 'b> { (x, y) }
existential type T<'a, 'b>; // = (&'a (), &'b ())
fn foo<'a>(x: &'a (), y: &'a ()) -> T<'a, 'a> { (x, y) }
// ^^ this can't be a defining use
// because this could exist: (doesn't use 'b *at all*)
fn bar<'a, 'b>(x: &'a (), y: &'a ()) -> T<'a, 'b> { (x, x) }
// OR this could exist: (*does* use 'b)
fn bar<'a, 'b>(x: &'a (), y: &'a ()) -> T<'a, 'b> { (x, y) }
// does this concrete type use `'b` or not?
fn bar<'a, 'b: 'a>(...) -> T<'a, 'b> { (x, y) }
what we want to allow, more depth
existential type T<'a, 'b>; // = (&'a (), &'b ())
fn foo<'a, 'b>(x: &'a (), y: &'b ()) -> T<'a, 'b> { (x, y) }
struct Foo<'a, 'b> {
..
}
impl<'a> Send for Foo<'a, 'a> {}
async fn make_foo(x: &'a u32, y; &'b u32) {
let x = Foo(x, y);
await!(some_thing());