Implement DataViews for Seq and Tuple (#2277)

* DataProducts for Seq and Tuple2-10 in DataProduct companion object
* DataViews for Seq and Tuple 2-10 in DataView companion object
* HWTuple2-10 Bundles in chisel3.experimental
* Implicit conversions from Seq to Vec and Tuple to HWTuple in chisel3.experimental.conversions

2 files changed, 481 insertions, 6 deletions

diff --git a/core/src/main/scala/chisel3/experimental/dataview/DataProduct.scala b/core/src/main/scala/chisel3/experimental/dataview/DataProduct.scala
index 55dd8505..438f97b8 100644
--- a/core/src/main/scala/chisel3/experimental/dataview/DataProduct.scala
+++ b/core/src/main/scala/chisel3/experimental/dataview/DataProduct.scala
@@ -3,7 +3,7 @@
 package chisel3.experimental.dataview
 
 import chisel3.experimental.BaseModule
-import chisel3.{Data, getRecursiveFields}
+import chisel3.{Data, Vec, getRecursiveFields}
 
 import scala.annotation.implicitNotFound
 
@@ -41,17 +41,24 @@ trait DataProduct[-A] {
   def dataSet(a: A): Data => Boolean = dataIterator(a, "").map(_._1).toSet
 }
 
-/** Encapsulating object for automatically provided implementations of [[DataProduct]]
+/** Low priority built-in implementations of [[DataProduct]]
   *
-  * @note DataProduct implementations provided in this object are available in the implicit scope
+  * @note This trait exists so that `dataDataProduct` can be lower priority than `seqDataProduct` to resolve ambiguity
   */
-object DataProduct {
+sealed trait LowPriorityDataProduct {
+
   /** [[DataProduct]] implementation for [[Data]] */
   implicit val dataDataProduct: DataProduct[Data] = new DataProduct[Data] {
     def dataIterator(a: Data, path: String): Iterator[(Data, String)] =
       getRecursiveFields.lazily(a, path).iterator
   }
+}
 
+/** Encapsulating object for built-in implementations of [[DataProduct]]
+  *
+  * @note DataProduct implementations provided in this object are available in the implicit scope
+  */
+object DataProduct extends LowPriorityDataProduct {
   /** [[DataProduct]] implementation for [[BaseModule]] */
   implicit val userModuleDataProduct: DataProduct[BaseModule] = new DataProduct[BaseModule] {
     def dataIterator(a: BaseModule, path: String): Iterator[(Data, String)] = {
@@ -69,4 +76,237 @@ object DataProduct {
       e => e._id > a._id && e._id <= lastId
     }
   }
+
+  /** [[DataProduct]] implementation for any `Seq[A]` where `A` has an implementation of `DataProduct`. */
+  implicit def seqDataProduct[A : DataProduct]: DataProduct[Seq[A]] = new DataProduct[Seq[A]] {
+    def dataIterator(a: Seq[A], path: String): Iterator[(Data, String)] = {
+      val dpa = implicitly[DataProduct[A]]
+      a.iterator
+        .zipWithIndex
+        .flatMap { case (elt, idx) =>
+          dpa.dataIterator(elt, s"$path[$idx]")
+        }
+    }
+  }
+
+  /** [[DataProduct]] implementation for any [[Tuple2]] where each field has an implementation of `DataProduct`. */
+  implicit def tuple2DataProduct[A : DataProduct, B : DataProduct]: DataProduct[(A, B)] = new DataProduct[(A, B)] {
+    def dataIterator(tup: (A, B), path: String): Iterator[(Data, String)] = {
+      val dpa = implicitly[DataProduct[A]]
+      val dpb = implicitly[DataProduct[B]]
+      val (a, b) = tup
+      dpa.dataIterator(a, s"$path._1") ++ dpb.dataIterator(b, s"$path._2")
+    }
+  }
+
+  /** [[DataProduct]] implementation for any [[Tuple3]] where each field has an implementation of `DataProduct`. */
+  implicit def tuple3DataProduct[A : DataProduct, B : DataProduct, C : DataProduct]: DataProduct[(A, B, C)] =
+    new DataProduct[(A, B, C)] {
+      def dataIterator(tup: (A, B, C), path: String): Iterator[(Data, String)] = {
+        val dpa = implicitly[DataProduct[A]]
+        val dpb = implicitly[DataProduct[B]]
+        val dpc = implicitly[DataProduct[C]]
+        val (a, b, c) = tup
+        dpa.dataIterator(a, s"$path._1") ++ dpb.dataIterator(b, s"$path._2") ++ dpc.dataIterator(c, s"$path._3")
+      }
+    }
+
+  /** [[DataProduct]] implementation for any [[Tuple4]] where each field has an implementation of `DataProduct`. */
+  implicit def tuple4DataProduct[A : DataProduct, B : DataProduct, C : DataProduct, D : DataProduct]: DataProduct[(A, B, C, D)] =
+    new DataProduct[(A, B, C, D)] {
+      def dataIterator(tup: (A, B, C, D), path: String): Iterator[(Data, String)] = {
+        val dpa = implicitly[DataProduct[A]]
+        val dpb = implicitly[DataProduct[B]]
+        val dpc = implicitly[DataProduct[C]]
+        val dpd = implicitly[DataProduct[D]]
+        val (a, b, c, d) = tup
+        dpa.dataIterator(a, s"$path._1") ++
+          dpb.dataIterator(b, s"$path._2") ++
+          dpc.dataIterator(c, s"$path._3") ++
+          dpd.dataIterator(d, s"$path._4")
+      }
+    }
+
+  /** [[DataProduct]] implementation for any [[Tuple5]] where each field has an implementation of `DataProduct`. */
+  implicit def tuple5DataProduct[
+      A : DataProduct,
+      B : DataProduct,
+      C : DataProduct,
+      D : DataProduct,
+      E : DataProduct]: DataProduct[(A, B, C, D, E)] =
+    new DataProduct[(A, B, C, D, E)] {
+      def dataIterator(tup: (A, B, C, D, E), path: String): Iterator[(Data, String)] = {
+        val dpa = implicitly[DataProduct[A]]
+        val dpb = implicitly[DataProduct[B]]
+        val dpc = implicitly[DataProduct[C]]
+        val dpd = implicitly[DataProduct[D]]
+        val dpe = implicitly[DataProduct[E]]
+        val (a, b, c, d, e) = tup
+        dpa.dataIterator(a, s"$path._1") ++
+          dpb.dataIterator(b, s"$path._2") ++
+          dpc.dataIterator(c, s"$path._3") ++
+          dpd.dataIterator(d, s"$path._4") ++
+          dpe.dataIterator(e, s"$path._5")
+      }
+    }
+
+  /** [[DataProduct]] implementation for any [[Tuple6]] where each field has an implementation of `DataProduct`. */
+  implicit def tuple6DataProduct[
+    A : DataProduct,
+    B : DataProduct,
+    C : DataProduct,
+    D : DataProduct,
+    E : DataProduct,
+    F : DataProduct]: DataProduct[(A, B, C, D, E, F)] =
+    new DataProduct[(A, B, C, D, E, F)] {
+      def dataIterator(tup: (A, B, C, D, E, F), path: String): Iterator[(Data, String)] = {
+        val dpa = implicitly[DataProduct[A]]
+        val dpb = implicitly[DataProduct[B]]
+        val dpc = implicitly[DataProduct[C]]
+        val dpd = implicitly[DataProduct[D]]
+        val dpe = implicitly[DataProduct[E]]
+        val dpf = implicitly[DataProduct[F]]
+        val (a, b, c, d, e, f) = tup
+        dpa.dataIterator(a, s"$path._1") ++
+          dpb.dataIterator(b, s"$path._2") ++
+          dpc.dataIterator(c, s"$path._3") ++
+          dpd.dataIterator(d, s"$path._4") ++
+          dpe.dataIterator(e, s"$path._5") ++
+          dpf.dataIterator(f, s"$path._6")
+      }
+    }
+
+  /** [[DataProduct]] implementation for any [[Tuple7]] where each field has an implementation of `DataProduct`. */
+  implicit def tuple7DataProduct[
+    A : DataProduct,
+    B : DataProduct,
+    C : DataProduct,
+    D : DataProduct,
+    E : DataProduct,
+    F : DataProduct,
+    G : DataProduct]: DataProduct[(A, B, C, D, E, F, G)] =
+    new DataProduct[(A, B, C, D, E, F, G)] {
+      def dataIterator(tup: (A, B, C, D, E, F, G), path: String): Iterator[(Data, String)] = {
+        val dpa = implicitly[DataProduct[A]]
+        val dpb = implicitly[DataProduct[B]]
+        val dpc = implicitly[DataProduct[C]]
+        val dpd = implicitly[DataProduct[D]]
+        val dpe = implicitly[DataProduct[E]]
+        val dpf = implicitly[DataProduct[F]]
+        val dpg = implicitly[DataProduct[G]]
+        val (a, b, c, d, e, f, g) = tup
+        dpa.dataIterator(a, s"$path._1") ++
+          dpb.dataIterator(b, s"$path._2") ++
+          dpc.dataIterator(c, s"$path._3") ++
+          dpd.dataIterator(d, s"$path._4") ++
+          dpe.dataIterator(e, s"$path._5") ++
+          dpf.dataIterator(f, s"$path._6") ++
+          dpg.dataIterator(g, s"$path._7")
+      }
+    }
+
+  /** [[DataProduct]] implementation for any [[Tuple8]] where each field has an implementation of `DataProduct`. */
+  implicit def tuple8DataProduct[
+    A : DataProduct,
+    B : DataProduct,
+    C : DataProduct,
+    D : DataProduct,
+    E : DataProduct,
+    F : DataProduct,
+    G : DataProduct,
+    H : DataProduct]: DataProduct[(A, B, C, D, E, F, G, H)] =
+    new DataProduct[(A, B, C, D, E, F, G, H)] {
+      def dataIterator(tup: (A, B, C, D, E, F, G, H), path: String): Iterator[(Data, String)] = {
+        val dpa = implicitly[DataProduct[A]]
+        val dpb = implicitly[DataProduct[B]]
+        val dpc = implicitly[DataProduct[C]]
+        val dpd = implicitly[DataProduct[D]]
+        val dpe = implicitly[DataProduct[E]]
+        val dpf = implicitly[DataProduct[F]]
+        val dpg = implicitly[DataProduct[G]]
+        val dph = implicitly[DataProduct[H]]
+        val (a, b, c, d, e, f, g, h) = tup
+        dpa.dataIterator(a, s"$path._1") ++
+          dpb.dataIterator(b, s"$path._2") ++
+          dpc.dataIterator(c, s"$path._3") ++
+          dpd.dataIterator(d, s"$path._4") ++
+          dpe.dataIterator(e, s"$path._5") ++
+          dpf.dataIterator(f, s"$path._6") ++
+          dpg.dataIterator(g, s"$path._7") ++
+          dph.dataIterator(h, s"$path._8")
+      }
+    }
+
+  /** [[DataProduct]] implementation for any [[Tuple9]] where each field has an implementation of `DataProduct`. */
+  implicit def tuple9DataProduct[
+    A : DataProduct,
+    B : DataProduct,
+    C : DataProduct,
+    D : DataProduct,
+    E : DataProduct,
+    F : DataProduct,
+    G : DataProduct,
+    H : DataProduct,
+    I : DataProduct]: DataProduct[(A, B, C, D, E, F, G, H, I)] =
+    new DataProduct[(A, B, C, D, E, F, G, H, I)] {
+      def dataIterator(tup: (A, B, C, D, E, F, G, H, I), path: String): Iterator[(Data, String)] = {
+        val dpa = implicitly[DataProduct[A]]
+        val dpb = implicitly[DataProduct[B]]
+        val dpc = implicitly[DataProduct[C]]
+        val dpd = implicitly[DataProduct[D]]
+        val dpe = implicitly[DataProduct[E]]
+        val dpf = implicitly[DataProduct[F]]
+        val dpg = implicitly[DataProduct[G]]
+        val dph = implicitly[DataProduct[H]]
+        val dpi = implicitly[DataProduct[I]]
+        val (a, b, c, d, e, f, g, h, i) = tup
+        dpa.dataIterator(a, s"$path._1") ++
+          dpb.dataIterator(b, s"$path._2") ++
+          dpc.dataIterator(c, s"$path._3") ++
+          dpd.dataIterator(d, s"$path._4") ++
+          dpe.dataIterator(e, s"$path._5") ++
+          dpf.dataIterator(f, s"$path._6") ++
+          dpg.dataIterator(g, s"$path._7") ++
+          dph.dataIterator(h, s"$path._8") ++
+          dpi.dataIterator(i, s"$path._9")
+      }
+    }
+
+  /** [[DataProduct]] implementation for any [[Tuple9]] where each field has an implementation of `DataProduct`. */
+  implicit def tuple10DataProduct[
+    A : DataProduct,
+    B : DataProduct,
+    C : DataProduct,
+    D : DataProduct,
+    E : DataProduct,
+    F : DataProduct,
+    G : DataProduct,
+    H : DataProduct,
+    I : DataProduct,
+    J : DataProduct]: DataProduct[(A, B, C, D, E, F, G, H, I, J)] =
+    new DataProduct[(A, B, C, D, E, F, G, H, I, J)] {
+      def dataIterator(tup: (A, B, C, D, E, F, G, H, I, J), path: String): Iterator[(Data, String)] = {
+        val dpa = implicitly[DataProduct[A]]
+        val dpb = implicitly[DataProduct[B]]
+        val dpc = implicitly[DataProduct[C]]
+        val dpd = implicitly[DataProduct[D]]
+        val dpe = implicitly[DataProduct[E]]
+        val dpf = implicitly[DataProduct[F]]
+        val dpg = implicitly[DataProduct[G]]
+        val dph = implicitly[DataProduct[H]]
+        val dpi = implicitly[DataProduct[I]]
+        val dpj = implicitly[DataProduct[J]]
+        val (a, b, c, d, e, f, g, h, i, j) = tup
+        dpa.dataIterator(a, s"$path._1") ++
+          dpb.dataIterator(b, s"$path._2") ++
+          dpc.dataIterator(c, s"$path._3") ++
+          dpd.dataIterator(d, s"$path._4") ++
+          dpe.dataIterator(e, s"$path._5") ++
+          dpf.dataIterator(f, s"$path._6") ++
+          dpg.dataIterator(g, s"$path._7") ++
+          dph.dataIterator(h, s"$path._8") ++
+          dpi.dataIterator(i, s"$path._9") ++
+          dpj.dataIterator(j, s"$path._10")
+      }
+    }
 }
diff --git a/core/src/main/scala/chisel3/experimental/dataview/DataView.scala b/core/src/main/scala/chisel3/experimental/dataview/DataView.scala
index caf004c2..c17a5574 100644
--- a/core/src/main/scala/chisel3/experimental/dataview/DataView.scala
+++ b/core/src/main/scala/chisel3/experimental/dataview/DataView.scala
@@ -3,9 +3,12 @@
 package chisel3.experimental.dataview
 
 import chisel3._
-import chisel3.internal.sourceinfo.SourceInfo
-import scala.reflect.runtime.universe.WeakTypeTag
+import chisel3.experimental.DataMirror.internal.chiselTypeClone
+import chisel3.experimental.{HWTuple10, HWTuple2, HWTuple3, HWTuple4, HWTuple5, HWTuple6, HWTuple7, HWTuple8, HWTuple9}
+import chisel3.internal.sourceinfo.{SourceInfo, UnlocatableSourceInfo}
+import chisel3.ExplicitCompileOptions.Strict
 
+import scala.reflect.runtime.universe.WeakTypeTag
 import annotation.implicitNotFound
 
 
@@ -132,9 +135,241 @@ object DataView {
     case (b, a) => f(a, b).map(_.swap)
   }
 
+  // ****************************** Built-in Implementations of DataView ******************************
+  // Sort of the "Standard library" implementations
+
   /** All Chisel Data are viewable as their own type */
   implicit def identityView[A <: Data](implicit sourceInfo: SourceInfo): DataView[A, A] =
     DataView[A, A](chiselTypeOf.apply, { case (x, y) => (x, y) })
+
+  /** Provides `DataView[Seq[A], Vec[B]]` for all `A` such that there exists `DataView[A, B]` */
+  implicit def seqDataView[A : DataProduct, B <: Data](implicit dv: DataView[A, B], sourceInfo: SourceInfo): DataView[Seq[A], Vec[B]] = {
+    // TODO this would need a better way to determine the prototype for the Vec
+    DataView.mapping[Seq[A], Vec[B]](
+      xs => Vec(xs.size, chiselTypeClone(xs.head.viewAs[B]))(sourceInfo, Strict), // xs.head is not correct in general
+      { case (s, v) => s.zip(v).map { case (a, b) => a.viewAs[B] -> b } }
+    )
+  }
+
+  /** Provides implementations of [[DataView]] for [[Tuple2]] to [[HWTuple2]]  */
+  implicit def tuple2DataView[T1 : DataProduct, T2 : DataProduct, V1 <: Data, V2 <: Data](
+    implicit v1: DataView[T1, V1], v2: DataView[T2, V2], sourceInfo: SourceInfo
+  ): DataView[(T1, T2), HWTuple2[V1, V2]] =
+    DataView.mapping(
+      { case (a, b) => new HWTuple2(a.viewAs[V1].cloneType, b.viewAs[V2].cloneType)},
+      { case ((a, b), hwt) =>
+        Seq(a.viewAs[V1] -> hwt._1,
+          b.viewAs[V2] -> hwt._2)
+      }
+    )
+
+  /** Provides implementations of [[DataView]] for [[Tuple3]] to [[HWTuple3]]  */
+  implicit def tuple3DataView[
+    T1 : DataProduct, T2 : DataProduct, T3 : DataProduct,
+    V1 <: Data, V2 <: Data, V3 <: Data
+  ](
+    implicit v1: DataView[T1, V1], v2: DataView[T2, V2], v3: DataView[T3, V3], sourceInfo: SourceInfo
+  ): DataView[(T1, T2, T3), HWTuple3[V1, V2, V3]] =
+    DataView.mapping(
+      { case (a, b, c) => new HWTuple3(a.viewAs[V1].cloneType, b.viewAs[V2].cloneType, c.viewAs[V3].cloneType)},
+      { case ((a, b, c), hwt) =>
+        Seq(a.viewAs[V1] -> hwt._1,
+            b.viewAs[V2] -> hwt._2,
+            c.viewAs[V3] -> hwt._3)
+      }
+    )
+
+  /** Provides implementations of [[DataView]] for [[Tuple4]] to [[HWTuple4]]  */
+  implicit def tuple4DataView[
+    T1 : DataProduct, T2 : DataProduct, T3 : DataProduct, T4 : DataProduct,
+    V1 <: Data, V2 <: Data, V3 <: Data, V4 <: Data
+  ](
+    implicit v1: DataView[T1, V1], v2: DataView[T2, V2], v3: DataView[T3, V3], v4: DataView[T4, V4], sourceInfo: SourceInfo
+  ): DataView[(T1, T2, T3, T4), HWTuple4[V1, V2, V3, V4]] =
+    DataView.mapping(
+      { case (a, b, c, d) =>
+          new HWTuple4(a.viewAs[V1].cloneType, b.viewAs[V2].cloneType, c.viewAs[V3].cloneType, d.viewAs[V4].cloneType
+      )},
+      { case ((a, b, c, d), hwt) =>
+        Seq(a.viewAs[V1] -> hwt._1,
+            b.viewAs[V2] -> hwt._2,
+            c.viewAs[V3] -> hwt._3,
+            d.viewAs[V4] -> hwt._4)
+      }
+    )
+
+  /** Provides implementations of [[DataView]] for [[Tuple5]] to [[HWTuple5]]  */
+  implicit def tuple5DataView[
+    T1 : DataProduct, T2 : DataProduct, T3 : DataProduct, T4 : DataProduct, T5 : DataProduct,
+    V1 <: Data, V2 <: Data, V3 <: Data, V4 <: Data, V5 <: Data
+  ](
+    implicit v1: DataView[T1, V1], v2: DataView[T2, V2], v3: DataView[T3, V3], v4: DataView[T4, V4], v5: DataView[T5, V5], sourceInfo: SourceInfo
+  ): DataView[(T1, T2, T3, T4, T5), HWTuple5[V1, V2, V3, V4, V5]] = {
+    DataView.mapping(
+      { case tup: Tuple5[T1, T2, T3, T4, T5] =>
+        val (a, b, c, d, e) = tup
+        new HWTuple5(a.viewAs[V1].cloneType, b.viewAs[V2].cloneType, c.viewAs[V3].cloneType, d.viewAs[V4].cloneType,
+          e.viewAs[V5].cloneType
+        )
+      },
+      { case ((a, b, c, d, e), hwt) =>
+        Seq(a.viewAs[V1] -> hwt._1,
+          b.viewAs[V2] -> hwt._2,
+          c.viewAs[V3] -> hwt._3,
+          d.viewAs[V4] -> hwt._4,
+          e.viewAs[V5] -> hwt._5)
+      }
+    )
+  }
+
+  /** Provides implementations of [[DataView]] for [[Tuple6]] to [[HWTuple6]]  */
+  implicit def tuple6DataView[
+    T1 : DataProduct, T2 : DataProduct, T3 : DataProduct, T4 : DataProduct, T5 : DataProduct,
+    T6 : DataProduct,
+    V1 <: Data, V2 <: Data, V3 <: Data, V4 <: Data, V5 <: Data,
+    V6 <: Data
+  ](
+    implicit v1: DataView[T1, V1], v2: DataView[T2, V2], v3: DataView[T3, V3], v4: DataView[T4, V4],
+             v5: DataView[T5, V5], v6: DataView[T6, V6],
+             sourceInfo: SourceInfo
+  ): DataView[(T1, T2, T3, T4, T5, T6), HWTuple6[V1, V2, V3, V4, V5, V6]] =
+    DataView.mapping(
+      { case (a, b, c, d, e, f) =>
+        new HWTuple6(a.viewAs[V1].cloneType, b.viewAs[V2].cloneType, c.viewAs[V3].cloneType, d.viewAs[V4].cloneType,
+          e.viewAs[V5].cloneType, f.viewAs[V6].cloneType
+        )
+      },
+      { case ((a, b, c, d, e, f), hwt) =>
+        Seq(a.viewAs[V1] -> hwt._1,
+          b.viewAs[V2] -> hwt._2,
+          c.viewAs[V3] -> hwt._3,
+          d.viewAs[V4] -> hwt._4,
+          e.viewAs[V5] -> hwt._5,
+          f.viewAs[V6] -> hwt._6)
+      }
+    )
+
+  /** Provides implementations of [[DataView]] for [[Tuple7]] to [[HWTuple7]]  */
+  implicit def tuple7DataView[
+    T1 : DataProduct, T2 : DataProduct, T3 : DataProduct, T4 : DataProduct, T5 : DataProduct,
+    T6 : DataProduct, T7 : DataProduct,
+    V1 <: Data, V2 <: Data, V3 <: Data, V4 <: Data, V5 <: Data,
+    V6 <: Data, V7 <: Data
+  ](
+    implicit v1: DataView[T1, V1], v2: DataView[T2, V2], v3: DataView[T3, V3], v4: DataView[T4, V4],
+             v5: DataView[T5, V5], v6: DataView[T6, V6], v7: DataView[T7, V7],
+             sourceInfo: SourceInfo
+  ): DataView[(T1, T2, T3, T4, T5, T6, T7), HWTuple7[V1, V2, V3, V4, V5, V6, V7]] =
+    DataView.mapping(
+      { case (a, b, c, d, e, f, g) =>
+        new HWTuple7(a.viewAs[V1].cloneType, b.viewAs[V2].cloneType, c.viewAs[V3].cloneType, d.viewAs[V4].cloneType,
+          e.viewAs[V5].cloneType, f.viewAs[V6].cloneType, g.viewAs[V7].cloneType
+        )
+      },
+      { case ((a, b, c, d, e, f, g), hwt) =>
+        Seq(a.viewAs[V1] -> hwt._1,
+          b.viewAs[V2] -> hwt._2,
+          c.viewAs[V3] -> hwt._3,
+          d.viewAs[V4] -> hwt._4,
+          e.viewAs[V5] -> hwt._5,
+          f.viewAs[V6] -> hwt._6,
+          g.viewAs[V7] -> hwt._7)
+      }
+    )
+
+  /** Provides implementations of [[DataView]] for [[Tuple8]] to [[HWTuple8]]  */
+  implicit def tuple8DataView[
+    T1 : DataProduct, T2 : DataProduct, T3 : DataProduct, T4 : DataProduct, T5 : DataProduct,
+    T6 : DataProduct, T7 : DataProduct, T8 : DataProduct,
+    V1 <: Data, V2 <: Data, V3 <: Data, V4 <: Data, V5 <: Data,
+    V6 <: Data, V7 <: Data, V8 <: Data
+  ](
+    implicit v1: DataView[T1, V1], v2: DataView[T2, V2], v3: DataView[T3, V3], v4: DataView[T4, V4],
+    v5: DataView[T5, V5], v6: DataView[T6, V6], v7: DataView[T7, V7], v8: DataView[T8, V8],
+    sourceInfo: SourceInfo
+  ): DataView[(T1, T2, T3, T4, T5, T6, T7, T8), HWTuple8[V1, V2, V3, V4, V5, V6, V7, V8]] =
+    DataView.mapping(
+      { case (a, b, c, d, e, f, g, h) =>
+        new HWTuple8(a.viewAs[V1].cloneType, b.viewAs[V2].cloneType, c.viewAs[V3].cloneType, d.viewAs[V4].cloneType,
+          e.viewAs[V5].cloneType, f.viewAs[V6].cloneType, g.viewAs[V7].cloneType, h.viewAs[V8].cloneType
+        )
+      },
+      { case ((a, b, c, d, e, f, g, h), hwt) =>
+        Seq(a.viewAs[V1] -> hwt._1,
+          b.viewAs[V2] -> hwt._2,
+          c.viewAs[V3] -> hwt._3,
+          d.viewAs[V4] -> hwt._4,
+          e.viewAs[V5] -> hwt._5,
+          f.viewAs[V6] -> hwt._6,
+          g.viewAs[V7] -> hwt._7,
+          h.viewAs[V8] -> hwt._8)
+      }
+    )
+
+  /** Provides implementations of [[DataView]] for [[Tuple9]] to [[HWTuple9]]  */
+  implicit def tuple9DataView[
+    T1 : DataProduct, T2 : DataProduct, T3 : DataProduct, T4 : DataProduct, T5 : DataProduct,
+    T6 : DataProduct, T7 : DataProduct, T8 : DataProduct, T9 : DataProduct,
+    V1 <: Data, V2 <: Data, V3 <: Data, V4 <: Data, V5 <: Data,
+    V6 <: Data, V7 <: Data, V8 <: Data, V9 <: Data
+  ](
+    implicit v1: DataView[T1, V1], v2: DataView[T2, V2], v3: DataView[T3, V3], v4: DataView[T4, V4],
+    v5: DataView[T5, V5], v6: DataView[T6, V6], v7: DataView[T7, V7], v8: DataView[T8, V8],
+    v9: DataView[T9, V9],
+    sourceInfo: SourceInfo
+  ): DataView[(T1, T2, T3, T4, T5, T6, T7, T8, T9), HWTuple9[V1, V2, V3, V4, V5, V6, V7, V8, V9]] =
+    DataView.mapping(
+      { case (a, b, c, d, e, f, g, h, i) =>
+        new HWTuple9(a.viewAs[V1].cloneType, b.viewAs[V2].cloneType, c.viewAs[V3].cloneType, d.viewAs[V4].cloneType,
+          e.viewAs[V5].cloneType, f.viewAs[V6].cloneType, g.viewAs[V7].cloneType, h.viewAs[V8].cloneType,
+          i.viewAs[V9].cloneType
+        )
+      },
+      { case ((a, b, c, d, e, f, g, h, i), hwt) =>
+        Seq(a.viewAs[V1] -> hwt._1,
+          b.viewAs[V2] -> hwt._2,
+          c.viewAs[V3] -> hwt._3,
+          d.viewAs[V4] -> hwt._4,
+          e.viewAs[V5] -> hwt._5,
+          f.viewAs[V6] -> hwt._6,
+          g.viewAs[V7] -> hwt._7,
+          h.viewAs[V8] -> hwt._8,
+          i.viewAs[V9] -> hwt._9)
+      }
+    )
+
+  /** Provides implementations of [[DataView]] for [[Tuple10]] to [[HWTuple10]]  */
+  implicit def tuple10DataView[
+    T1 : DataProduct, T2 : DataProduct, T3 : DataProduct, T4 : DataProduct, T5 : DataProduct,
+    T6 : DataProduct, T7 : DataProduct, T8 : DataProduct, T9 : DataProduct, T10 : DataProduct,
+    V1 <: Data, V2 <: Data, V3 <: Data, V4 <: Data, V5 <: Data,
+    V6 <: Data, V7 <: Data, V8 <: Data, V9 <: Data, V10 <: Data
+  ](
+    implicit v1: DataView[T1, V1], v2: DataView[T2, V2], v3: DataView[T3, V3], v4: DataView[T4, V4],
+    v5: DataView[T5, V5], v6: DataView[T6, V6], v7: DataView[T7, V7], v8: DataView[T8, V8],
+    v9: DataView[T9, V9], v10: DataView[T10, V10],
+    sourceInfo: SourceInfo
+  ): DataView[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), HWTuple10[V1, V2, V3, V4, V5, V6, V7, V8, V9, V10]] =
+    DataView.mapping(
+      { case (a, b, c, d, e, f, g, h, i, j) =>
+        new HWTuple10(a.viewAs[V1].cloneType, b.viewAs[V2].cloneType, c.viewAs[V3].cloneType, d.viewAs[V4].cloneType,
+          e.viewAs[V5].cloneType, f.viewAs[V6].cloneType, g.viewAs[V7].cloneType, h.viewAs[V8].cloneType,
+          i.viewAs[V9].cloneType, j.viewAs[V10].cloneType
+        )
+      },
+      { case ((a, b, c, d, e, f, g, h, i, j), hwt) =>
+        Seq(a.viewAs[V1] -> hwt._1,
+          b.viewAs[V2] -> hwt._2,
+          c.viewAs[V3] -> hwt._3,
+          d.viewAs[V4] -> hwt._4,
+          e.viewAs[V5] -> hwt._5,
+          f.viewAs[V6] -> hwt._6,
+          g.viewAs[V7] -> hwt._7,
+          h.viewAs[V8] -> hwt._8,
+          i.viewAs[V9] -> hwt._9,
+          j.viewAs[V10] -> hwt._10)
+      }
+    )
 }
 
 /** Factory methods for constructing non-total [[DataView]]s */