type_val 0.3.3

Type-level values.
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

#![no_std]

/*! This crate allows for the creation
  of type-level values. Any value can
  be type-level as long as it can be
  initialized as a constant. All
  type-level values implement the
  TypeVal trait, and so can be provided
  as type parameters.
  
  ## Example
  
  ```rust
  #[macro_use]
  extern crate type_val;
  use type_val::TypeVal;

  use std::marker::PhantomData;

  fn main() {
      let mut adder = Adder::<Two, One>::new();
      
      assert_eq!(adder.sum, 2);
      
      adder.add();
      
      assert_eq!(adder.sum, 3);
  }
  
  def_type_val! {
      type One: u32 = 1;
      type Two: u32 = 2;
  }
  
  struct Adder<S, I> {
      sum: u32,
      _marker: PhantomData<(S, I)>,
  }
  
  impl <S, I> Adder<S, I>
      where S: TypeVal<u32>,
            I: TypeVal<u32>,
  {
      fn new() -> Adder<S, I> {
          Adder {
              // Get the value of S
              sum: S::VAL,
              _marker: PhantomData,
          }
      }
      
      fn add(&mut self) {
          // Get the value of I
          self.sum += I::VAL;
      }
  }
  ```
!*/

/// A trait implemented by type-level values.
pub trait TypeVal<T> {
    /// The value held.
    const VAL: T;
}

/** This macro is used to implement the
  TypeVal trait. Any number of values
  can be initialized with a single
  invocation. Items prefixed by `pub`
  are public. Attributes to be applied
  to items in a block, including doc
  comments, should go above their
  targets.
 
  ## Example
 
  ```rust
  def_type_val! {
      type One: i32 = 1;
      #[derive(Clone, Copy)]
      type True: bool = true;
      /// Negative one
      pub type NegOne: i32 = -1;
      pub type False: bool = false;
   }
 
  println!("One = {}, True = {}, NegOne = {}, False = {}",
      One::VAL,
      True::VAL,
      NegOne::VAL,
      False::VAL);
  ```
**/
#[macro_export]
macro_rules! def_type_val {
    {$(#[$attr:meta])* type $name:ident: $type:ty = $value:expr; $($next:tt)*} => {
        $(#[$attr])*
        struct $name;
        
        impl $crate::TypeVal<$type> for $name {
            const VAL: $type = $value;
        }
        
        def_type_val!($($next)*);
    };
    {$(#[$attr:meta])* pub type $name:ident: $type:ty = $value:expr; $($next:tt)*} => {
        $(#[$attr])*
        pub struct $name;
        
        impl $crate::TypeVal<$type> for $name {
            const VAL: $type = $value;
        }
        
        def_type_val!($($next)*);
    };
    () => {};
}