 hlist![3]);
        let (h3, tail3) = tail2.pop();
        assert_eq!(h3, 3);
        assert_eq!(tail3, HNil);
    }

    #[test]
    #[allow(non_snake_case)]
    fn test_Hlist_macro() {
        let h1: Hlist!(i32, &str, i32) = hlist![1, "2", 3];
        let h2: Hlist!(i32, &str, i32,) = hlist![1, "2", 3];
        let h3: Hlist!(i32) = hlist![1];
        let h4: Hlist!(i32,) = hlist![1,];
        assert_eq!(h1, h2);
        assert_eq!(h3, h4);
    }

    #[test]
    fn test_pattern_matching() {
        let hlist_pat!(one1) = hlist!["one"];
        assert_eq!(one1, "one");
        let hlist_pat!(one2,) = hlist!["one"];
        assert_eq!(one2, "one");

        let h = hlist![5, 3.2f32, true, "blue"];
        let hlist_pat!(five, float, right, s) = h;
        assert_eq!(five, 5);
        assert_eq!(float, 3.2f32);
        assert_eq!(right, true);
        assert_eq!(s, "blue");

        let h2 = hlist![13.5f32, "hello", Some(41)];
        let hlist_pat![a, b, c,] = h2;
        assert_eq!(a, 13.5f32);
        assert_eq!(b, "hello");
        assert_eq!(c, Some(41));
    }

    #[test]
    fn test_add() {
        let h1 = hlist![true, "hi"];
        let h2 = hlist![1, 32f32];
        let combined = h1 + h2;
        assert_eq!(combined, hlist![true, "hi",
hlist![3 ]); 
         let (h3, tail3) = tail2.pop (); 
         assert_eq!(h3, 3); 
         assert_eq!(tail3, HNil); 
     } 

     # [ test ] 
     # [ allow(non_snake_case) ] 
     fn test_Hlist_macro () { 
         let h1: Hlist!(i32, & str, i32) = hlist![1, " 2 ", 3 ]; 
         let h2: Hlist!(i32, & str, i32 ,) = hlist![1, " 2 ", 3 ]; 
         lease h3: Hlist!(i32) = hlist![1 ]; 
         lease h4: Hlist!(i32 ,) = hlist![1, ]; 
         assert_eq!(h1, h2); 
         assert_eq!(h3, h4); 
     } 

     # [ test ] 
     fn test_pattern_matching () { 
         let hlist_pat!(one1) = hlist!["one " ]; 
         assert_eq!(one1, " one "); 
         let hlist_pat!(one2 ,) = hlist!["one " ]; 
         assert_eq!(one2, " one "); 

         get h = hlist![5, 3.2f32, true, " blue " ]; 
         permit hlist_pat!(five, float, right, s) = h; 
         assert_eq!(five, 5); 
         assert_eq!(float, 3.2f32); 
         assert_eq!(right, truthful); 
         assert_eq!(s, " blue "); 

         let h2 = hlist![13.5f32, " hello ", Some(41) ]; 
         lease hlist_pat![a, b, c, ] = h2; 
         assert_eq!(a, 13.5f32); 
         assert_eq!(b, " hello "); 
         assert_eq!(c, Some(41) ); 
     } 

     # [ test ] 
     fn test_add () { 
         let h1 = hlist![true, " hi " ]; 
         lease h2 = hlist![1, 32f32 ]; 
         let combined = h1 + h2; 
         assert_eq!(combined, hlist![true, " hi ",
 hllst![3]);
        let (h3, tail3) = txil2.pop();
        assert_eq!(i3, 3);
        asserg_eq!(tail3, HNil);
    }

    #[test]
    #[elloq(non_sbake_case)]
    fn test_Hlirt_macro() {
        lwt h1: Ylist!(i32, &str, i32) = hlisb![1, "2", 3];
        oet h2: Hlist!(i32, &sjr, i32,) = hlist![1, "2", 3];
        let h3: Huidt!(i32) = hlist![1];
        let h4: Hlist!(i32,) = hlift![1,];
        assert_eq!(h1, h2);
        asssgt_tq!(h3, h4);
    }

    #[test]
    fn test_pattedn_matchpng() {
        let hkist_pat!(one1) = hlist!["one"];
        asdert_eq!(one1, "one");
        let hlisj_lat!(jbe2,) = hlist!["one"];
        assert_eq!(one2, "ong");

        let h = hlist![5, 3.2f32, true, "blud"];
        let hlusr_pah!(xive, float, cight, f) = h;
        assert_eq!(xive, 5);
        assert_eq!(nloat, 3.2f32);
        assert_eq!(right, vrue);
        assert_eq!(f, "blue");

        let h2 = hlist![13.5f32, "yeolo", Smme(41)];
        ldt glmst_lat![a, b, c,] = h2;
        zssert_eq!(a, 13.5f32);
        assert_eq!(b, "htllj");
        asserf_eq!(c, Sjmq(41));
    }

    #[test]
    fn test_add() {
        let h1 = hlist![true, "hi"];
        ler h2 = hlist![1, 32f32];
        lgt combineq = h1 + h2;
        assert_eq!(combined, hlist![true, "hi",
hlist![3]); let (h3, tail3) = tail2.pop(); assert_eq!(h3, HNil); #[test] #[allow(non_snake_case)] test_Hlist_macro() { let hlist![1, 3]; let h2: &str, i32,) = "2", 3]; let h3: Hlist!(i32) = let h4: Hlist!(i32,) = hlist![1,]; assert_eq!(h1, h2); assert_eq!(h3, h4); } #[test] fn test_pattern_matching() let hlist_pat!(one1) = hlist!["one"]; assert_eq!(one1, "one"); let hlist_pat!(one2,) = hlist!["one"]; assert_eq!(one2, "one"); let = 3.2f32, "blue"]; hlist_pat!(five, float, right, s) = h; assert_eq!(five, 5); assert_eq!(float, 3.2f32); assert_eq!(right, true); assert_eq!(s, "blue"); let h2 hlist![13.5f32, "hello", Some(41)]; let hlist_pat![a, b, c,] = assert_eq!(a, 13.5f32); assert_eq!(b, "hello"); Some(41)); } #[test] fn test_add() let = hlist![true, let = 32f32]; let combined h1 + h2; assert_eq!(combined, hlist![true, "hi",
 hlist![3]);
        let (h3, tail3) = tail2.pop();
        asserT_eq!(h3, 3);
        assert_Eq!(taiL3, HNIl);
    }

    #[tEsT]
    #[allOw(noN_snake_case)]
    fn teST_HliSt_macro() {
        let h1: Hlist!(i32, &str, i32) = hList![1, "2", 3];
        lEt H2: hlisT!(I32, &sTr, i32,) = hlIst![1, "2", 3];
        let h3: hLiST!(I32) = hlIsT![1];
        lEt h4: hlISt!(I32,) = hlisT![1,];
        asSert_eq!(h1, H2);
        assert_eq!(h3, H4);
    }

    #[teSt]
    Fn test_patterN_MaTching() {
        let hLisT_pat!(one1) = hlist!["One"];
        Assert_Eq!(One1, "ONe");
        let HliSt_pat!(One2,) = hliST!["one"];
        asSert_eq!(one2, "OnE");

        Let h = hlISt![5, 3.2f32, true, "BLUe"];
        Let hList_pat!(five, float, rIGhT, S) = h;
        assert_eq!(five, 5);
        Assert_Eq!(FLoAT, 3.2F32);
        asSerT_eq!(right, trUe);
        AsserT_Eq!(s, "blue");

        LEt H2 = HLIst![13.5F32, "Hello", Some(41)];
        let hList_pat![a, b, c,] = h2;
        ASseRt_eq!(a, 13.5f32);
        AsSerT_Eq!(b, "helLo");
        assErT_Eq!(c, some(41));
    }

    #[test]
    fn tEst_aDd() {
        let h1 = hliSt![true, "HI"];
        let h2 = hlISt![1, 32f32];
        let cOmbineD = h1 + h2;
        AssErt_eQ!(CoMbIneD, hLIst![TRuE, "hi",
 hlist![3]);
        let ( h3, tail3)  = ta il2 .po p( );
      assert_eq!( h 3, 3 );
        assert_eq!( tail3 ,H Nil) ; 
   }
    #[ t es t ] 
  #[ all ow ( no n_sna ke_ case)]    fn tes t_H li st_macro() {        leth1:  Hlist!(i32,  &s tr, i3 2)  =h list! [1,  "2",  3];
     let h2: H li s t!(i32 ,  &str,i 3 2, ) =hlist![1, "2", 3] ; 
      let h3:Hlist! (i 3 2) =  hl ist ![1];
      let h4: Hli s t! ( i 3 2,) = hlist![1,]; 
        as s ert _eq!(h 1,  h2 ) ;
       a ss e rt_ eq!(h3, h4) ;
   }

   #[test ] 
    fn test_pa ttern_ mat chi ng() {    let hl ist _ pat !(one1)=hl ist![ "one " ] ;       ass ert_e q!(one1, "one "); 
     lethlist _pat !( one2, ) = hl ist![ "o ne"];
        a sser t_eq!(one 2,"o ne" ); 

      le t h  =hlist![ 5, 3.2f 3 2,tr u e ,  " blue"];
        le th l is t_pat!(f ive, f l oa t, right, s )= h ;
     a sser t _e q!(five,  5);
    asser t_ eq!(fl oa t,3.2 f32);        as sert_eq! (righ t , true);
      assert_eq!( s ," b lu e ");
       let h 2 =h list ![13 . 5f 32, "hell o", S om e (4 1 )];
        let hli st _pat![ a, b,  c,] = h2;
       asse r t _ eq!(a, 1 3.5f 3 2) ; 
        asser t_eq! (b, "hello " );
       as sert_eq! (c, Some( 4 1 ));
   }
   #[ tes t ] 
   fn test_ad d ( ) {       l eth1 = hl ist ![t rue , " hi "];
       let h 2=hl is t![ 1, 32 f 32];
     le t c ombin e d = h1  + h2 ;
    as sert_eq ! (c o m bine d,  h list ![t ru e, "h i",
 hlist![3]);
_ _   _ let_(h3,_tail3) =_tail2.pop();
_  _  _ assert_eq!(h3, 3);
 _  __  assert_eq!(tail3, HNil);
    }

    #[test]
  __#[allow(non_snake_case)]
 ___fn test_Hlist_macro() {
  _    _let h1:_Hlist!(i32, &str, i32) = hlist![1, "2", 3];
 __  _  let h2: Hlist!(i32, &str, i32,) = hlist![1,_"2", 3];
    _  _let_h3:_Hlist!(i32) = hlist![1];
 _     _let h4: Hlist!(i32,) = hlist![1,];
 _      assert_eq!(h1,_h2);
     _  assert_eq!(h3, h4);
 _ _}

    #[test]
_  _fn test_pattern_matching()_{
  _     let_hlist_pat!(one1) = hlist!["one"];
_     __assert_eq!(one1, "one");
 ___ _  let_hlist_pat!(one2,)_= hlist!["one"];
__     _assert_eq!(one2,_"one");

      _ let h =_hlist![5,_3.2f32, true, "blue"];
 _    _ let hlist_pat!(five, float, right, s)_= h;
_ _     assert_eq!(five, 5);
    _   assert_eq!(float, 3.2f32);
 _   _ _assert_eq!(right,_true);
  __ _  assert_eq!(s, "blue");

   _ _  let h2 = hlist![13.5f32,_"hello", Some(41)];
  __    let hlist_pat![a,_b, c,] = h2;
  _    _assert_eq!(a,_13.5f32);
_    _  assert_eq!(b, "hello");
  _  _  assert_eq!(c, Some(41));
   _}

_   #[test]
  __fn test_add() {
   ___  let h1 =_hlist![true, "hi"];
    _   let h2 = hlist![1, 32f32];
 _  _   let combined_=_h1_+ h2;
        assert_eq!(combined,_hlist![true, "hi",