Remove bound on tail in Cons struct

src/lib.rs

@@ -77,9 +77,7 @@ pub struct Nil;
 
 /// Heterogenous list with head and tail values, where tail is another heterogenous list.
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash, Default)]
-pub struct Cons<Head, Tail>(pub Head, pub Tail)
-where
-    Tail: HList;
+pub struct Cons<Head, Tail>(pub Head, pub Tail);
 
 /// Compile-time heterogenous list.
 ///
@@ -149,9 +147,9 @@ where
 mod sealed {
     pub trait Sealed {}
 
-    impl Sealed for super::Nil {}
+    impl Sealed for crate::Nil {}
 
-    impl<Head, Tail> Sealed for super::Cons<Head, Tail> where Tail: super::HList {}
+    impl<Head, Tail> Sealed for crate::Cons<Head, Tail> {}
 }
 
 /// Macro creating heterogenous list values from list of expressions.

src/ops/append.rs

@@ -37,6 +37,7 @@ where
 
     fn append<T>(self, value: T) -> Self::Output<T> {
         let Cons(head, tail) = self;
-        Cons(head, tail.append(value))
+        let tail = tail.append(value);
+        Cons(head, tail)
     }
 }

src/ops/extend.rs

@@ -28,7 +28,9 @@ pub trait Extend: HList {
 }
 
 impl Extend for Nil {
-    type Output<T> = T where T: HList;
+    type Output<T> = T
+    where
+        T: HList;
 
     fn extend<T>(self, list: T) -> Self::Output<T>
     where
@@ -42,13 +44,16 @@ impl<Head, Tail> Extend for Cons<Head, Tail>
 where
     Tail: Extend,
 {
-    type Output<T> = Cons<Head, Tail::Output<T>> where T: HList;
+    type Output<T> = Cons<Head, Tail::Output<T>>
+    where
+        T: HList;
 
     fn extend<T>(self, list: T) -> Self::Output<T>
     where
         T: HList,
     {
         let Cons(head, tail) = self;
-        Cons(head, tail.extend(list))
+        let tail = tail.extend(list);
+        Cons(head, tail)
     }
 }

src/ops/fold.rs

@@ -39,7 +39,7 @@ pub trait Fold<Accumulator, Folder>: HList {
     /// );
     /// assert_eq!(folded, 42.0);
     /// ```
-    fn fold(self, init: Accumulator, f: Folder) -> Accumulator;
+    fn fold(self, init: Accumulator, folder: Folder) -> Accumulator;
 }
 
 impl<A, F> Fold<A, F> for Nil {
@@ -53,23 +53,22 @@ where
     F: FnMut(A, Head) -> A,
     Tail: Fold<A, F>,
 {
-    fn fold(self, init: A, mut f: F) -> A {
+    fn fold(self, init: A, mut folder: F) -> A {
         let Cons(head, tail) = self;
-        let init = f(init, head);
-        tail.fold(init, f)
+        let init = folder(init, head);
+        tail.fold(init, folder)
     }
 }
 
 impl<A, FHead, FTail, Head, Tail> Fold<A, Cons<FHead, FTail>> for Cons<Head, Tail>
 where
     FHead: FnOnce(A, Head) -> A,
-    FTail: HList,
     Tail: Fold<A, FTail>,
 {
-    fn fold(self, init: A, f: Cons<FHead, FTail>) -> A {
+    fn fold(self, init: A, folder: Cons<FHead, FTail>) -> A {
         let Cons(head, tail) = self;
-        let Cons(f_head, f_tail) = f;
-        let init = f_head(init, head);
-        tail.fold(init, f_tail)
+        let Cons(folder_head, folder_tail) = folder;
+        let init = folder_head(init, head);
+        tail.fold(init, folder_tail)
     }
 }

src/ops/map.rs

@@ -34,7 +34,7 @@ pub trait Map<Mapper>: HList {
     /// );
     /// assert_eq!(list, hlist!(3, 0.0, false));
     /// ```
-    fn map(self, m: Mapper) -> Self::Output;
+    fn map(self, mapper: Mapper) -> Self::Output;
 }
 
 impl<M> Map<M> for Nil {
@@ -52,23 +52,22 @@ where
 {
     type Output = Cons<R, Tail::Output>;
 
-    fn map(self, mut m: M) -> Self::Output {
+    fn map(self, mut mapper: M) -> Self::Output {
         let Cons(head, tail) = self;
-        Cons(m(head), tail.map(m))
+        Cons(mapper(head), tail.map(mapper))
     }
 }
 
 impl<MHead, MTail, Head, Tail, R> Map<Cons<MHead, MTail>> for Cons<Head, Tail>
 where
     MHead: FnOnce(Head) -> R,
-    MTail: HList,
     Tail: Map<MTail>,
 {
     type Output = Cons<R, Tail::Output>;
 
-    fn map(self, m: Cons<MHead, MTail>) -> Self::Output {
+    fn map(self, mapper: Cons<MHead, MTail>) -> Self::Output {
         let Cons(head, tail) = self;
-        let Cons(m_head, m_tail) = m;
-        Cons(m_head(head), tail.map(m_tail))
+        let Cons(mapper_head, mapper_tail) = mapper;
+        Cons(mapper_head(head), tail.map(mapper_tail))
     }
 }

src/ops/rfold.rs

@@ -45,7 +45,7 @@ pub trait RFold<Accumulator, Folder>: HList {
     /// );
     /// assert_eq!(folded, 9001.0);
     /// ```
-    fn rfold(self, init: Accumulator, f: Folder) -> Accumulator;
+    fn rfold(self, init: Accumulator, folder: Folder) -> Accumulator;
 }
 
 impl<A, F> RFold<A, F> for Nil {
@@ -59,23 +59,22 @@ where
     F: FnMut(A, Head) -> A,
     Tail: for<'a> RFold<A, &'a mut F>,
 {
-    fn rfold(self, init: A, mut f: F) -> A {
+    fn rfold(self, init: A, mut folder: F) -> A {
         let Cons(head, tail) = self;
-        let init = tail.rfold(init, &mut f);
-        f(init, head)
+        let init = tail.rfold(init, &mut folder);
+        folder(init, head)
     }
 }
 
 impl<A, FHead, FTail, Head, Tail> RFold<A, Cons<FHead, FTail>> for Cons<Head, Tail>
 where
     FHead: FnOnce(A, Head) -> A,
-    FTail: HList,
     Tail: RFold<A, FTail>,
 {
-    fn rfold(self, init: A, f: Cons<FHead, FTail>) -> A {
+    fn rfold(self, init: A, folder: Cons<FHead, FTail>) -> A {
         let Cons(head, tail) = self;
-        let Cons(f_head, f_tail) = f;
-        let init = tail.rfold(init, f_tail);
-        f_head(init, head)
+        let Cons(folder_head, folder_tail) = folder;
+        let init = tail.rfold(init, folder_tail);
+        folder_head(init, head)
     }
 }

src/ops/to_mut.rs

@@ -43,6 +43,7 @@ where
 
     fn to_mut(&mut self) -> Self::Output<'_> {
         let Cons(head, tail) = self;
-        Cons(head, tail.to_mut())
+        let tail = tail.to_mut();
+        Cons(head, tail)
     }
 }

src/ops/to_ref.rs

@@ -43,6 +43,7 @@ where
 
     fn to_ref(&self) -> Self::Output<'_> {
         let Cons(head, tail) = self;
-        Cons(head, tail.to_ref())
+        let tail = tail.to_ref();
+        Cons(head, tail)
     }
 }

src/ops/unzip.rs

@@ -51,8 +51,11 @@ where
 
     fn unzip(self) -> (Self::First, Self::Second) {
         let Cons(head, tail) = self;
-        let (tail_first, tail_second) = tail.unzip();
         let (head_first, head_second) = head.destruct();
-        (Cons(head_first, tail_first), Cons(head_second, tail_second))
+        let (tail_first, tail_second) = tail.unzip();
+
+        let first = Cons(head_first, tail_first);
+        let second = Cons(head_second, tail_second);
+        (first, second)
     }
 }

src/ops/zip.rs

@@ -46,7 +46,10 @@ where
 
     fn zip(self, other: Cons<OHead, OTail>) -> Self::Output {
         let Cons(head, tail) = self;
-        let Cons(o_head, o_tail) = other;
-        Cons((head, o_head), tail.zip(o_tail))
+        let Cons(other_head, other_tail) = other;
+
+        let head = (head, other_head);
+        let tail = tail.zip(other_tail);
+        Cons(head, tail)
     }
 }