Merge pull request milessabin#532 from tpolecat/ToSizedHList

milessabin · milessabin · commit 82081c148d32 · 2016-01-15T08:21:18.000Z
Add ToSizedHList
diff --git a/core/src/main/scala/shapeless/ops/sizeds.scala b/core/src/main/scala/shapeless/ops/sizeds.scala
@@ -9,7 +9,7 @@ object sized {
    *
    * @author Alexandre Archambault
    */
-  trait ToHList[-Repr, L <: Nat] {
+  trait ToHList[-Repr, L <: Nat] extends Serializable {
     type Out <: HList
     def apply(s: Sized[Repr, L]): Out
   }
diff --git a/core/src/main/scala/shapeless/ops/traversables.scala b/core/src/main/scala/shapeless/ops/traversables.scala
@@ -51,4 +51,50 @@ object traversable {
           else for(h <- l.head.cast[OutH]; t <- flt(l.tail)) yield h :: t
     }
   }
+
+  /**
+   * Type class supporting type safe conversion of `Traversables` to `HLists` of a specific length.
+   * 
+   * @author Rob Norris
+   */
+  trait ToSizedHList[CC[T] <: GenTraversable[T], A, N <: Nat] extends Serializable {
+    type Out
+    def apply(cc: CC[A]): Out
+  }
+
+  /**
+   * `ToSizedHList` type class instances.
+   * 
+   * @author Rob Norris
+   */
+  object ToSizedHList {
+
+    def apply[CC[T] <: GenTraversable[T], A, N <: Nat](
+      implicit ev: ToSizedHList[CC, A, N]
+    ): ToSizedHList.Aux[CC, A, N, ev.Out] = 
+      ev
+
+    import syntax.sized._
+    import ops.nat._
+    import ops.sized._
+
+    type Aux[CC[T] <: GenTraversable[T], A, N <: Nat, Out0] =
+      ToSizedHList[CC, A, N] {
+        type Out = Out0
+      }
+
+    implicit def instance[CC[T] <: GenTraversable[T], A, N <: Nat](
+      implicit gt: CC[A] => GenTraversableLike[A, CC[A]], 
+               ac: AdditiveCollection[CC[A]],
+               ti: ToInt[N], 
+               th: ToHList[CC[A], N]
+    ): Aux[CC, A, N, Option[th.Out]] =
+      new ToSizedHList[CC, A, N] {
+        type Out = Option[th.Out]
+        def apply(as: CC[A]): Out =
+          as.sized[N].map(_.toHList)
+      }
+
+  }
+
 }
diff --git a/core/src/main/scala/shapeless/syntax/std/traversables.scala b/core/src/main/scala/shapeless/syntax/std/traversables.scala
@@ -27,13 +27,21 @@ import scala.collection.GenTraversable
  * typed [[shapeless.HList]] if possible. 
  * 
  * @author Miles Sabin
+ * @author Rob Norris
  */
 object traversable {
   implicit def traversableOps[T <% GenTraversable[_]](t : T) = new TraversableOps(t)
+  implicit def traversableOps2[CC[T] <: GenTraversable[T], A](as: CC[A]) = new TraversableOps2(as)
 }
 
 final class TraversableOps[T <% GenTraversable[_]](t : T) {
   import ops.traversable._
 
   def toHList[L <: HList](implicit fl : FromTraversable[L]) : Option[L] = fl(t)
 }
+
+final class TraversableOps2[CC[T] <: GenTraversable[T], A](as: CC[A]) {
+  import ops.traversable._
+
+  def toSizedHList(n: Nat)(implicit ts: ToSizedHList[CC, A, n.N]): ts.Out = ts(as)
+}
diff --git a/core/src/test/scala/shapeless/hlist.scala b/core/src/test/scala/shapeless/hlist.scala
@@ -34,6 +34,8 @@ class HListTests {
   type SI = Set[Int] :: HNil
   type OI = Option[Int] :: HNil
 
+  type III = Int :: Int :: Int :: HNil
+
   type SISS = Set[Int] :: Set[String] :: HNil
   type OIOS = Option[Int] :: Option[String] :: HNil
 
@@ -3136,4 +3138,12 @@ class HListTests {
     illTyped(""" (1 :: "a" :: 3 :: HNil).slice(0, 4) """)
     illTyped(""" (1 :: "a" :: 3 :: HNil).slice(1, 0) """)
   }
+
+  @Test
+  def testToSizedHList {
+    val ns = List(1,2,3,4)
+    assertTypedEquals[Option[III]](None, ns.toSizedHList(3))
+    assertTypedEquals[Option[IIII]](Some(1 :: 2 :: 3 :: 4 :: HNil), ns.toSizedHList(4))
+  }
+
 }
diff --git a/core/src/test/scala/shapeless/serialization.scala b/core/src/test/scala/shapeless/serialization.scala
@@ -900,6 +900,15 @@ class SerializationTests {
   def testTraversable {
     type L = Int :: String :: Boolean :: HNil
     assertSerializable(FromTraversable[L])
+
+    // To satisfy serialization of `ToSizedHList` we must provide a serializable `IsTraversableLike`
+    // that will get picked up for the `ops.sized.ToHList` we're using. I'm not convinced that this
+    // is entirely ethical since real-life usage will almost certainly fail, or at least until the
+    // instance in stdlib is fixed. - rob/tpolecat
+    import scala.collection.generic.IsTraversableLike
+    implicit val hack: IsTraversableLike[List[Int]] { type A = Int } = null
+    assertSerializable(ToSizedHList[List, Int, _4])
+
   }
 
   @Test

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ object sized {`
`9`	`9`	`*`
`10`	`10`	`* @author Alexandre Archambault`
`11`	`11`	`*/`
`12`		`- trait ToHList[-Repr, L <: Nat] {`
	`12`	`+ trait ToHList[-Repr, L <: Nat] extends Serializable {`
`13`	`13`	`type Out <: HList`
`14`	`14`	`def apply(s: Sized[Repr, L]): Out`
`15`	`15`	`}`