delegation 0.4.0

Macro-based delegation for enums and structs.
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

#[doc(hidden)]
pub use codegen::impl_for;

/// Enum for holding either `L` or `R` type.
#[derive(Clone, Copy, Debug)]
pub enum Either<L, R> {
    /// Left type.
    Left(L),

    /// Right type.
    Right(R),
}

/// Type of unreachable [`Either`] variant.
#[derive(Clone, Copy, Debug)]
pub enum Void {}

/// Wrapper around `T` to implement traits for delegation.
#[derive(Clone, Copy, Debug)]
#[repr(transparent)]
pub struct Wrapper<T: ?Sized>(pub T);

/// Type for interacting with external traits.
#[derive(Clone, Copy, Debug)]
#[repr(transparent)]
pub struct External;

/// Trait for converting a type into its delegate.
pub trait Convert {
    /// Type of owned any enum variant.
    type Owned;

    /// Type of referenced any enum variant.
    type Ref<'a>
    where
        Self: 'a;

    /// Type of mutable referenced any enum variant.
    type RefMut<'a>
    where
        Self: 'a;

    /// Converts this enum into an owned variant.
    fn convert_owned(self) -> Self::Owned;

    /// Converts reference to this enum into a variant reference.
    fn convert_ref(&self) -> Self::Ref<'_>;

    /// Converts mutable reference to this enum into a mutable variant
    /// reference.
    fn convert_ref_mut(&mut self) -> Self::RefMut<'_>;
}

/// Trait for retrieving an actual type from a bind type.
pub trait TypeOf {
    /// Actual type associated with the bind.
    type T;
}