cgp-tests 0.5.0-beta

Context-generic programming meta crate
Documentation 
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
97
98
99
100
101

#![allow(dead_code)]

use cgp::core::macros::blanket_trait;

#[test]
pub fn test_basic_blanket_trait() {
    pub trait Foo {}
    pub trait Bar {}

    #[blanket_trait]
    pub trait FooBar: Foo + Bar {}

    pub struct Context;

    impl Foo for Context {}
    impl Bar for Context {}

    pub trait CanUseFooBar: FooBar {}
    impl CanUseFooBar for Context {}
}

#[test]
pub fn test_blanket_trait_with_method() {
    pub trait Foo {
        fn foo(&self);
    }
    pub trait Bar {
        fn bar(&self);
    }

    #[blanket_trait]
    pub trait FooBar: Foo + Bar {
        fn foo_bar(&self) {
            self.foo();
            self.bar();
        }
    }

    pub struct Context;

    impl Foo for Context {
        fn foo(&self) {}
    }

    impl Bar for Context {
        fn bar(&self) {}
    }

    pub trait CanUseFooBar: FooBar {}
    impl CanUseFooBar for Context {}
}

#[test]
pub fn test_blanket_trait_with_associated_type_without_constraints() {
    pub trait HasFooTypeAt<I> {
        type Foo;
    }

    pub struct Bar;

    #[blanket_trait]
    pub trait HasFooTypeAtBar: HasFooTypeAt<Bar, Foo = Self::FooBar> {
        type FooBar;
    }

    pub struct Context;
    pub struct FooBar;

    impl HasFooTypeAt<Bar> for Context {
        type Foo = FooBar;
    }

    pub trait CanUseFooTypeAtBar: HasFooTypeAtBar<FooBar = FooBar> {}
    impl CanUseFooTypeAtBar for Context {}
}

#[test]
pub fn test_blanket_trait_with_associated_type_and_constraints() {
    pub trait HasFooTypeAt<I> {
        type Foo;
    }

    pub struct Bar;

    #[blanket_trait]
    pub trait HasFooTypeAtBar: HasFooTypeAt<Bar, Foo = Self::FooBar> {
        type FooBar: Clone;
    }

    pub struct Context;

    #[derive(Clone)]
    pub struct FooBar;

    impl HasFooTypeAt<Bar> for Context {
        type Foo = FooBar;
    }

    pub trait CanUseFooTypeAtBar: HasFooTypeAtBar<FooBar = FooBar> {}
    impl CanUseFooTypeAtBar for Context {}
}