1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
trait T0<'a, A> {
type O;
}
struct L<T> {
f: T,
}
// explicitly named variants of what one would normally denote by the
// unit type `()`. Why do this? So that we can differentiate them in
// the diagnostic output.
struct Unit1;
struct Unit2;
struct Unit3;
struct Unit4;
impl<'a, A, T> T0<'a, A> for L<T>
where
T: FnMut(A) -> Unit3,
{
type O = T::Output;
}
trait T1: for<'r> Ty<'r> {
fn m<'a, B: Ty<'a>, F>(&self, f: F) -> Unit1
where
F: for<'r> T0<'r, (<Self as Ty<'r>>::V,), O = <B as Ty<'r>>::V>,
{
unimplemented!();
}
}
trait Ty<'a> {
type V;
}
fn main() {
let v = Unit2.m(
L {
//~^ ERROR to be a closure that returns `Unit3`, but it returns `Unit4`
//~| ERROR type mismatch
f: |x| {
drop(x);
Unit4
},
},
);
}
impl<'a> Ty<'a> for Unit2 {
type V = &'a u8;
}
impl T1 for Unit2 {}
|
