compris 0.0.11

Composite Primitive Schema (CPS) for Rust
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

/// Helper macro for implementing [Annotated](super::Annotated).
#[macro_export]
macro_rules! impl_annotated {
    ( $type:ident $(,)? ) => {
        $crate::impl_annotated!($type, annotated);
    };

    ( $type:ident, $field:ident $(,)? ) => {
        impl<AnnotatedT> $crate::annotate::Annotated for $type<AnnotatedT>
        where
            AnnotatedT: $crate::annotate::Annotated,
        {
            fn can_have_annotations() -> bool {
                AnnotatedT::can_have_annotations()
            }

            fn annotations(&self) -> ::std::option::Option<&$crate::annotate::Annotations> {
                self.$field.annotations()
            }

            fn annotations_mut(&mut self) -> ::std::option::Option<&mut $crate::annotate::Annotations> {
                self.$field.annotations_mut()
            }
        }
    };
}

/// Helper macro for implementing [DynAnnotatedError](super::DynAnnotatedError).
#[macro_export]
macro_rules! impl_dyn_annotated_error {
    ( $type:ident $(,)? ) => {
        $crate::impl_dyn_annotated_error!($type, annotated);
    };

    ( $type:ident, $field:ident $(,)? ) => {
        $crate::impl_annotated!($type, $field);

        impl<AnnotatedT> $type<AnnotatedT> {
            /// Captured.
            pub fn captured(self) -> $crate::annotate::CapturedAnnotatedError
            where
                AnnotatedT: 'static
                    + $crate::annotate::Annotated
                    + ::std::fmt::Debug
                    + ::std::marker::Send
                    + ::std::marker::Sync,
            {
                ::std::boxed::Box::new(self)
            }
        }

        impl<AnnotatedT> $crate::annotate::DynAnnotatedError for $type<AnnotatedT> where
            AnnotatedT: $crate::annotate::Annotated + ::std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync
        {
        }

        impl<AnnotatedT> Into<$crate::annotate::CapturedAnnotatedError> for $type<AnnotatedT>
        where
            AnnotatedT:
                'static + $crate::annotate::Annotated + ::std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync,
        {
            fn into(self) -> $crate::annotate::CapturedAnnotatedError {
                self.captured()
            }
        }
    };
}

#[allow(unused_imports)]
pub use {impl_annotated, impl_dyn_annotated_error};