Merge pull request milessabin#524 from clhodapp/feature/unwrapped

milessabin · milessabin · commit d6a4f56e0783 · 2016-01-04T21:36:29.000Z
Add Unwrapped typeclass for unwrapping in codecs
diff --git a/core/src/main/scala/shapeless/syntax/unwrapped.scala b/core/src/main/scala/shapeless/syntax/unwrapped.scala
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2016 Miles Sabin 
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package shapeless
+package syntax
+
+object unwrapped {
+  implicit class UnwrappedSyntax[T](val t: T) extends AnyVal {
+    def unwrap[U](implicit uw: Unwrapped.Aux[T, U]): U = uw.unwrap(t)
+    def wrap[W](implicit uw: Unwrapped.Aux[W, T]): W = uw.wrap(t)
+  }
+}
diff --git a/core/src/main/scala/shapeless/unwrapped.scala b/core/src/main/scala/shapeless/unwrapped.scala
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2016 Miles Sabin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package shapeless
+
+import newtype._
+
+trait Unwrapped[W] extends Serializable {
+  type U
+  def unwrap(w: W): U
+  def wrap(u: U): W
+}
+
+object Unwrapped extends UnwrappedInstances {
+  type Aux[W, U0] = Unwrapped[W] { type U = U0 }
+  def apply[W](implicit w: Unwrapped[W]): Aux[W, w.U] = w
+}
+
+trait UnwrappedInstances extends LowPriorityUnwrappedInstances {
+  implicit def unwrapAnyVal[W <: AnyVal, Repr, UI, UF](implicit
+    gen: Generic.Aux[W, Repr],
+    avh: AnyValHelper.Aux[Repr, UI],
+    chain: Strict[Unwrapped.Aux[UI, UF]]
+  ) = new Unwrapped[W] {
+    type U = UF
+    def unwrap(w: W): U = chain.value.unwrap(avh.unwrap(gen.to(w)))
+    def wrap(u: U): W = gen.from(avh.wrap(chain.value.wrap(u)))
+  }
+
+  sealed trait AnyValHelper[Repr] extends Serializable {
+    type U
+    def unwrap(r: Repr): U
+    def wrap(u: U): Repr
+  }
+  object AnyValHelper {
+    type Aux[Repr, U0] = AnyValHelper[Repr] { type U = U0 }
+    implicit def sizeOneHListHelper[T] =
+      SizeOneHListHelper.asInstanceOf[AnyValHelper.Aux[T :: HNil, T]]
+    val SizeOneHListHelper = new AnyValHelper[Any :: HNil] {
+      type U = Any
+      def unwrap(hl: Any :: HNil): Any = hl.head
+      def wrap(t: Any): Any :: HNil = t :: HNil
+    }
+  }
+
+  implicit def newtypeUnwrapped[UI, Ops, UF](implicit
+    chain: Strict[Unwrapped.Aux[UI, UF]]
+  ) = chain.value.asInstanceOf[Unwrapped.Aux[Newtype[UI, Ops], UF]]
+
+}
+
+trait LowPriorityUnwrappedInstances {
+  val theSelfUnwrapped =
+    new Unwrapped[Any] {
+      type U = Any
+      def unwrap(t: Any) = t
+      def wrap(t: Any) = t
+    }
+  implicit def selfUnwrapped[T] =
+    theSelfUnwrapped.asInstanceOf[Unwrapped.Aux[T, T]]
+}
diff --git a/core/src/test/scala/shapeless/unwrapped.scala b/core/src/test/scala/shapeless/unwrapped.scala
@@ -0,0 +1,159 @@
+
+/*
+ * Copyright (c) 2016 Miles Sabin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package shapeless
+
+import org.junit.Test
+
+object WrappedTests {
+  trait TestTag
+  case class AvWrapper(stringValue: String) extends AnyVal
+}
+import WrappedTests._
+
+class UnwrappedTests {
+
+  sealed trait Pass[T] {
+    type U
+    def actual(t: T): T
+    def unwrapped(t: T): U
+    def wrapped(u: U): T
+  }
+  object Pass {
+    type Aux[T, U0] = Pass[T] { type U = U0 }
+    implicit def unwrappedPasses[W, U0](implicit uw: Unwrapped.Aux[W, U0]): Pass.Aux[W, U0] =
+      new Pass[W] {
+        type U = U0
+        def actual(w: W): W = w
+        def unwrapped(w: W): U = uw.unwrap(w)
+        def wrapped(u: U): W = uw.wrap(u)
+      }
+  }
+
+  @Test
+  def testAnyVal: Unit = {
+    val pass = the[Pass[AvWrapper]]
+    the[pass.U =:= String]
+    val avw = AvWrapper("testing")
+    val actual = pass.actual(avw)
+    val wrapped = pass.wrapped(avw.stringValue)
+    val unwrapped = pass.unwrapped(avw)
+    assert((actual: AvWrapper) == avw)
+    assert((wrapped: AvWrapper) == avw)
+    assert((unwrapped: String) == avw.stringValue)
+  }
+
+  @Test
+  def testNewtype: Unit = {
+    import newtype._
+    case class MyStringOps(s: String) {
+      def stringValue: String = s
+    }
+    type MyString = Newtype[String, MyStringOps]
+    def MyString(s : String) : MyString = newtype(s)
+    implicit val mkOps = MyStringOps
+
+    val pass = the[Pass[MyString]]
+    the[pass.U =:= String]
+    val ms = MyString("testing")
+    val actual = pass.actual(ms)
+    val wrapped = pass.wrapped(ms.stringValue)
+    val unwrapped = pass.unwrapped(ms)
+    assert((actual: MyString) == ms)
+    assert((wrapped: MyString) == ms)
+    assert((unwrapped: String) == ms.stringValue)
+  }
+
+  @Test
+  def testScalazTagged: Unit = {
+
+    type Tagged[A, T] = { type Tag = T; type Self = A }
+    type @@[T, Tag] = Tagged[T, Tag]
+
+    def tag[U] = new Tagger[U]
+    class Tagger[U] {
+      def apply[T](t : T) : T @@ U = t.asInstanceOf[T @@ U]
+    }
+    def value[T](t: Tagged[T, _]): T = t.asInstanceOf[T]
+
+    implicit def taggedUnwrapped[UI, T, UF](implicit chain: Lazy[Unwrapped.Aux[UI, UF]]) =
+      new Unwrapped[UI @@ T] {
+        type U = UF
+        def unwrap(w: UI @@ T) = chain.value.unwrap(value(w))
+        def wrap(u: UF) = tag[T](chain.value.wrap(u))
+      }
+
+    val pass = the[Pass[String @@ TestTag]]
+    the[pass.U =:= String]
+    val tagged = tag[TestTag]("testing")
+    val actual = pass.actual(tagged)
+    val wrapped = pass.wrapped(value(tagged))
+    val unwrapped = pass.unwrapped(tagged)
+    assert((actual: String @@ TestTag) == tagged)
+    assert((wrapped: String @@ TestTag) == tagged)
+    assert((unwrapped: String) == value(tagged))
+    test.illTyped("unwrapped: String @@ TestTag")
+  }
+
+  @Test
+  def testAlreadyUnwrapped: Unit = {
+
+    val pass = the[Pass[String]]
+    the[pass.U =:= String]
+    val raw = "testing"
+    val actual = pass.actual(raw)
+    val wrapped = pass.wrapped(raw)
+    val unwrapped = pass.unwrapped(raw)
+    assert((actual: String) == raw)
+    assert((wrapped: String) == raw)
+    assert((unwrapped: String) == raw)
+  }
+
+  @Test
+  def unwrapsChain: Unit = {
+    import newtype._
+
+    case class MyStringOps(s: AvWrapper) {
+      def stringValue: String = s.stringValue
+    }
+    type MyString = Newtype[AvWrapper, MyStringOps]
+    def MyString(a: AvWrapper): MyString = newtype(a)
+    implicit val mkOps = MyStringOps
+
+
+    val ms = MyString(AvWrapper("testing"))
+
+    val pass = the[Pass[MyString]]
+    the[pass.U =:= String]
+    val actual = pass.actual(ms)
+    val wrapped = pass.wrapped(ms.stringValue)
+    val unwrapped = pass.unwrapped(ms)
+    assert((actual: MyString) == ms)
+    assert((wrapped: MyString) == ms)
+    assert((unwrapped: String) == ms.stringValue)
+  }
+
+  @Test
+  def testSyntax: Unit = {
+    import syntax.unwrapped._
+    val w = "testing".wrap[AvWrapper]
+    test.typed(w: AvWrapper)
+    val u = w.unwrap
+    test.typed(u: String)
+  }
+
+}
diff --git a/examples/src/main/scala/shapeless/examples/unwrapped.scala b/examples/src/main/scala/shapeless/examples/unwrapped.scala
