#![feature(adt_const_params)]
use constduck::*;

#[derive(ConstDuck)]
struct Donald {
    money: i64,
}

>(t: &mut T) where N: Clone, N: Sub , N: From { t.set(t.get().clone() - N::from(5i8)); } ">

fn deduct_money
     >(t: 
     &
     mut T) 
    
     where N: 
     Clone,
        N: Sub
     
      ,
        N: 
      From<
      i8> {
    t.
      set(t.
      get().
      clone() 
      - N
      ::
      from(
      5i8));
}
     
    

macro_rules! make_getter {
    ($struct:ident.$field:ident) => {
        impl $struct {
            pub fn $field(&self) -> &/* What to write here? */ {
                &self.$field
            }
        }
    }
}

struct Foo {
    bar: String,
    baz: u32,
}

make_getter!(Foo.bar);

macro_rules! make_getter {
    ($struct:ident.$field:ident) => {
        impl
    $
   struct
            
   where 
   Self: 
   Field<{ stringify!($field) }, Ty = T> {
            
   pub fn $
   field(
   &
   self) 
   -
   > 
   &T {
                
   <
   Self 
   as Field
   <{ 
   stringify!($field) }
   >>
   ::
   get(
   self)
            }
        }
    }
}

#[derive(ConstDuck)]

   struct 
   Foo {
    bar: 
   String,
    baz: 
   u32,
}


   make_getter!(Foo.bar);
  

macro_rules! create_struct {
    ($struct:ident; $($name:ident: $value:expr),*) => {{
        // For some good reason we want to generate a separate wrapper struct first and return that instead of collecting directly into `$struct`.
        struct WrapperStruct<$($name,)*> {
            $($name: $name,)*
        }

        impl<$($name,)*> From
   <$($name,)*>> 
   for $
   struct {
            
   fn 
   from(wrapper: WrapperStruct<$($name,)*>) -> 
   Self {
                
   // wrapper.counter is not guaranteed to be a u32
                
   // So we cannot do this:
                $struct {
                    counter: wrapper.counter,
                    text: wrapper.text,
                }
            }
        }

        WrapperStruct {
            $($name: $value,)
   *
        }
    }}
}
  

impl<$($name,)*> From
   <$($name,)*>> 
   for $
   struct 
    
   where $
   struct: 
   ConstructFrom
   
    <$($name,)*>> {
    
    fn 
    from(wrapper: WrapperStruct<$($name,)*>) -> 
    Self {
        $struct
    ::
    construct(wrapper)
    }
}