rules_derive 0.3.0

simple and fast derive macros using macro_rules
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

//! Example of deriving `HeapSize` for a struct.
//! 
//! Provides examples of: 
//! * specializing rules_derive to structs.
//! * accessing struct fields by name, rather than by pattern matching.
use rules_derive::rules_derive;
use rules_derive::with_spans;

pub trait HeapSize {
  fn heap_size(&self) -> usize;
}

macro_rules! HeapSize {
  (
    ($( ($($attr:tt)*) )*)
    $vis:vis /* require a struct */ struct $name:ident (($ty:ty) ($($generics_bindings:tt)*) ($($generics_inner:tt)*) where ($($generics_where:tt)*)) {
      $variant_name:ident $variant:tt {
        $(
          $fieldvis:vis $fieldnameident:ident @ $fieldname:tt : $fieldty:ty,
        )*
      }
    }
  ) => {
    with_spans!{
      impl $($generics_bindings)* $crate::HeapSize for $ty where
        $($generics_where)*
        $(
          spanned!($fieldty => $fieldty: $crate::HeapSize,)
        )*
      {
        fn heap_size(&self) -> usize {
          // It's known to be a struct so we can directly access the field names.
          $(
            self.$fieldname.heap_size()
            +
          )*
          0
        }
      }
    }
  }
}

#[allow(dead_code)]
#[rules_derive(HeapSize)]
pub struct Unit;

#[allow(dead_code)]
#[rules_derive(HeapSize)]
pub struct Unnamed(u32, u32);

impl HeapSize for u32 {
  fn heap_size(&self) -> usize { 4 }
}

fn main() {}