blob: 93a44c01ce053f46c311c883be30fef05c0c4674 (
plain)
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
|
// run-pass
#![feature(associated_type_bounds)]
#![feature(type_alias_impl_trait)]
use std::ops::Add;
trait Tr1 {
type As1;
fn mk(self) -> Self::As1;
}
trait Tr2<'a> {
fn tr2(self) -> &'a Self;
}
fn assert_copy<T: Copy>(x: T) {
let _x = x;
let _x = x;
}
fn assert_static<T: 'static>(_: T) {}
fn assert_forall_tr2<T: for<'a> Tr2<'a>>(_: T) {}
struct S1;
#[derive(Copy, Clone)]
struct S2;
impl Tr1 for S1 {
type As1 = S2;
fn mk(self) -> Self::As1 {
S2
}
}
type Et1 = impl Tr1<As1: Copy>;
fn def_et1() -> Et1 {
S1
}
pub fn use_et1() {
assert_copy(def_et1().mk());
}
type Et2 = impl Tr1<As1: 'static>;
fn def_et2() -> Et2 {
S1
}
pub fn use_et2() {
assert_static(def_et2().mk());
}
type Et3 = impl Tr1<As1: Clone + Iterator<Item: Add<u8, Output: Into<u8>>>>;
fn def_et3() -> Et3 {
struct A;
impl Tr1 for A {
type As1 = core::ops::Range<u8>;
fn mk(self) -> Self::As1 {
0..10
}
}
A
}
pub fn use_et3() {
let _0 = def_et3().mk().clone();
let mut s = 0u8;
for _1 in _0 {
let _2 = _1 + 1u8;
s += _2.into();
}
assert_eq!(s, (0..10).map(|x| x + 1).sum());
}
type Et4 = impl Tr1<As1: for<'a> Tr2<'a>>;
fn def_et4() -> Et4 {
#[derive(Copy, Clone)]
struct A;
impl Tr1 for A {
type As1 = A;
fn mk(self) -> A {
A
}
}
impl<'a> Tr2<'a> for A {
fn tr2(self) -> &'a Self {
&A
}
}
A
}
pub fn use_et4() {
assert_forall_tr2(def_et4().mk());
}
fn main() {
use_et1();
use_et2();
use_et3();
use_et4();
}
|
