supply 0.3.1

Provider API for arbitrary number of lifetimes.
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

//! Extra requests.
//!
//! All types implementing [`Tagged`](ty_tag::Tagged) can be used as a request.
//! This module provides some extra combinations of requests.

use ty_tag::lifetime_list::LifetimeList;

use super::{Request, Want};
use crate::want::ErasedWantFor;

macro_rules! impl_reqx {
    ($name:ident: $($type:ident),*) => {
        /// Combine multiple requests into one.
        ///
        /// This allows requesting multiple values at the same time.
        #[derive(Default, Debug)]
        pub struct $name<$($type),*>($($type),*);

        impl<L: LifetimeList $(, $type)*> Request<L> for $name<$($type),*>
        where
            $($type: Request<L>,)*
        {
            // Acts as it's own want that knows how to do both.
            type Want = $name<$($type::Want),*>;

            type Output = ($($type::Output),*);

            #[allow(non_snake_case)]
            fn into_output(want: Self::Want) -> Self::Output {
                let $name($($type),*) = want;

                ($($type::into_output($type)),*)
            }
        }

        impl<L: LifetimeList $(, $type)*> Want<L> for $name<$($type),*>
        where
            $($type: Want<L>,)*
        {
            #[allow(non_snake_case)]
            fn try_for_id(
                &mut self,
                tag_type_id: ty_tag::TagTypeId<L>,
            ) -> Option<ErasedWantFor<'_, L>> {
                let $name($($type),*) = self;

                $(if !$type.is_satisfied() {
                    if let Some(want) = $type.try_for_id(tag_type_id) {
                        return Some(want);
                    }
                })*

                None
            }

            #[allow(non_snake_case)]
            fn is_satisfied(&self) -> bool {
                let $name($($type),*) = self;

                $($type.is_satisfied())&&*
            }
        }
    };
}

/// Trait for [`Option`].
///
/// This is used by the `ReqAllN` types.
///
/// This trait is sealed and cannot be implemented.
pub trait Optional: optional_seal::Sealed {
    type Value;

    fn into_option(self) -> Option<Self::Value>;
}

impl<T> Optional for Option<T> {
    type Value = T;

    fn into_option(self) -> Option<Self::Value> {
        self
    }
}

mod optional_seal {
    pub trait Sealed {}

    impl<T> Sealed for Option<T> {}
}

macro_rules! impl_reqx_all {
    ($name:ident: $($type:ident),*) => {
        /// Request a value of each type.
        ///
        /// If any type's value isn't given then the request returns `None`.
        #[derive(Default, Debug)]
        pub struct $name<$($type),*>($($type),*);

        impl<L: LifetimeList $(, $type)*> Request<L> for $name<$($type),*>
        where
            $($type: Request<L>,)*
            $($type::Output: Optional,)*
        {
            // Acts as it's own want that knows how to do both.
            type Want = $name<$($type::Want),*>;

            type Output = Option<($(<$type::Output as Optional>::Value),*)>;

            #[allow(non_snake_case)]
            fn into_output(want: Self::Want) -> Self::Output {
                let $name($($type),*) = want;

                $(
                let $type = $type::into_output($type).into_option();
                )*

                if let ($(Some($type)),*) = ($($type),*) {
                    Some(($($type),*))
                } else {
                    None
                }
            }
        }

        impl<L: LifetimeList $(, $type)*> Want<L> for $name<$($type),*>
        where
            $($type: Want<L>,)*
        {
            #[allow(non_snake_case)]
            fn try_for_id(
                &mut self,
                tag_type_id: ty_tag::TagTypeId<L>,
            ) -> Option<ErasedWantFor<'_, L>> {
                let $name($($type),*) = self;

                $(if !$type.is_satisfied() {
                    if let Some(want) = $type.try_for_id(tag_type_id) {
                        return Some(want);
                    }
                })*

                None
            }

            #[allow(non_snake_case)]
            fn is_satisfied(&self) -> bool {
                let $name($($type),*) = self;

                $($type.is_satisfied())&&*
            }
        }
    };
}

impl_reqx!(Req2: T0, T1);
impl_reqx!(Req3: T0, T1, T2);
impl_reqx!(Req4: T0, T1, T2, T3);
impl_reqx!(Req5: T0, T1, T2, T3, T4);
impl_reqx!(Req6: T0, T1, T2, T3, T4, T5);

impl_reqx_all!(ReqAll2: T0, T1);
impl_reqx_all!(ReqAll3: T0, T1, T2);
impl_reqx_all!(ReqAll4: T0, T1, T2, T3);
impl_reqx_all!(ReqAll5: T0, T1, T2, T3, T4);
impl_reqx_all!(ReqAll6: T0, T1, T2, T3, T4, T5);