tylift 0.3.0

Lift enum variants to the type-level.
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

#![feature(prelude_import)]
#![no_std]
#[prelude_import]
use ::std::prelude::v1::*;
#[macro_use]
extern crate std as std;
use tylift::tylift;

pub use __tylift_enum_Bool::*;
mod __tylift_enum_Bool {
    use super::*;
    pub trait Bool: __sealed::__Sealed { }
    pub struct False(::std::marker::PhantomData<()>);
    impl Bool for False<> { }
    pub struct True(::std::marker::PhantomData<()>);
    impl Bool for True<> { }
    mod __sealed {
        use super::*;
        pub trait __Sealed { }
        impl __Sealed for False<> { }
        impl __Sealed for True<> { }
    }
}

pub(crate) use __tylift_enum_Nat::*;
mod __tylift_enum_Nat {
    use super::*;
    pub trait Nat: __sealed::__Sealed { }
    pub struct Zero(::std::marker::PhantomData<()>);
    impl Nat for Zero<> { }
    pub struct Succ<__T0: Nat>(::std::marker::PhantomData<(__T0)>);
    impl <__T0: Nat> Nat for Succ<__T0> { }
    mod __sealed {
        use super::*;
        pub trait __Sealed { }
        impl __Sealed for Zero<> { }
        impl <__T0: Nat> __Sealed for Succ<__T0> { }
    }
}

use __tylift_enum_BinaryTree::*;
mod __tylift_enum_BinaryTree {
    use super::*;
    pub trait BinaryTree: __sealed::__Sealed { }
    pub struct Leaf(::std::marker::PhantomData<()>);
    impl BinaryTree for Leaf<> { }
    pub struct Branch<__T0: BinaryTree, __T1: Nat,
                      __T2: BinaryTree>(::std::marker::PhantomData<(__T0,
                                                                    __T1,
                                                                    __T2)>);
    impl <__T0: BinaryTree, __T1: Nat, __T2: BinaryTree> BinaryTree for
     Branch<__T0, __T1, __T2> {
    }
    mod __sealed {
        use super::*;
        pub trait __Sealed { }
        impl __Sealed for Leaf<> { }
        impl <__T0: BinaryTree, __T1: Nat, __T2: BinaryTree> __Sealed for
         Branch<__T0, __T1, __T2> {
        }
    }
}

fn main() { }