depends 0.11.0

Ergonomic, performant, incremental computation between arbitrary types
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

use crate::{
    error::ResolveResult, Dependency, DependencyEdge, HashValue, IsDirty, Named, NodeRef, Resolve,
    Visitor,
};

macro_rules! generate_dependencies {
    ($count:expr, $($param:expr),*) => {
        paste::paste! {
            pub struct [<Dependencies $count>]<$([<T $param >]),*> (
                $(Dependency<[<T $param >]>,)*
            );

            impl<$([<T $param >]),*> Named for [<Dependencies $count>]<$([<T $param >]),*> {
                fn name() -> &'static str {
                     stringify!([<Dependencies $count>])
                }
            }

            impl<$([<T $param >]),*> [<Dependencies $count>]<$([<T $param >]),*>
            where
                $([<T $param >]: Resolve,)*
                $(for<'a> <[<T $param >] as Resolve>::Output<'a>: HashValue,)*
            {
                #[allow(clippy::too_many_arguments)]
                pub fn new($([<t $param >]: [<T $param >]),*) -> Self {
                    Self (
                        $(Dependency::new([<t $param >])),*
                    )
                }
            }

            pub struct [<DependencyReference $count>]<'a, $([<T $param >]),*> (
                $(pub DependencyEdge<'a, [<T $param >]>,)*
            );

            pub type [<DepRef $count>]<'a, $([<T $param >]),*> = [<DependencyReference $count>]<'a, $(NodeRef<'a, [<T $param >]>),*>;

            impl<$([<T $param >]),*> IsDirty for [<DependencyReference $count>]<'_, $([<T $param >]),*> {
                fn is_dirty(&self) -> bool {
                    $(self.[< $param >].is_dirty() )||*
                }
            }

            impl<$([<T $param >]),*> Resolve for [<Dependencies $count>]<$([<T $param >]),*>
            where
                $([<T $param >]: Resolve,)*
                $(for<'a> <[<T $param >] as Resolve>::Output<'a>: HashValue,)*
            {
                type Output<'a> = [<DependencyReference $count>]<'a, $([<T $param >]::Output<'a>),*>
                where
                    Self: 'a;

                fn resolve(&self, visitor: &mut impl Visitor) -> ResolveResult<Self::Output<'_>> {
                    visitor.touch_dependency_group(Self::name());
                    Ok([<DependencyReference $count>] (
                        $(self.[< $param >].resolve(visitor)?),*
                    ))
                }
            }
        }
    };
}

generate_dependencies!(2, 0, 1);
generate_dependencies!(3, 0, 1, 2);
generate_dependencies!(4, 0, 1, 2, 3);
generate_dependencies!(5, 0, 1, 2, 3, 4);
generate_dependencies!(6, 0, 1, 2, 3, 4, 5);
generate_dependencies!(7, 0, 1, 2, 3, 4, 5, 6);
generate_dependencies!(8, 0, 1, 2, 3, 4, 5, 6, 7);
generate_dependencies!(9, 0, 1, 2, 3, 4, 5, 6, 7, 8);
generate_dependencies!(10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
generate_dependencies!(11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
generate_dependencies!(12, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
generate_dependencies!(13, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
generate_dependencies!(14, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
generate_dependencies!(15, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14);
generate_dependencies!(16, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);