👶

Author: Alejandro Gómez

.gitignore

@@ -0,0 +1,32 @@
+project/project
+project/target
+target
+.idea
+.tmp
+
+*.iml
+/out
+.idea_modules
+.classpath
+.project
+/RUNNING_PID
+.settings
+.sass-cache
+scalajvm/upload/*
+
+# temp files
+.~*
+*~
+*.orig
+
+# eclipse
+.scala_dependencies
+.buildpath
+.cache
+.target
+bin/
+.ensime
+.ensime_cache
+
+# OSX
+.DS_Store

.travis.yml

@@ -0,0 +1,5 @@
+language: scala
+scala:
+  - 2.11.7
+jdk:
+  - oraclejdk8

build.sbt

@@ -0,0 +1,21 @@
+lazy val shapeless = (project in file("."))
+.enablePlugins(ExerciseCompilerPlugin)
+.settings(
+  organization := "org.scalaexercises",
+  name            := "content-shapeless",
+  scalaVersion := "2.11.7",
+  version := "0.0.0-SNAPSHOT",
+  resolvers ++= Seq(
+    Resolver.sonatypeRepo("snapshots")
+  ),
+  libraryDependencies ++= Seq(
+    "org.typelevel" %% "cats-core" % "0.4.1",
+    "com.chuusai" %% "shapeless" % "2.2.5",
+    "org.scalatest" %% "scalatest" % "2.2.4",
+    "org.scalaexercises" %% "runtime" % "0.0.0-SNAPSHOT" changing(),
+    "org.scalaexercises" %% "definitions" % "0.0.0-SNAPSHOT" changing(),
+    "org.scalacheck" %% "scalacheck" % "1.12.5",
+    "com.github.alexarchambault" %% "scalacheck-shapeless_1.12" % "0.3.1",
+    compilerPlugin("org.spire-math" %% "kind-projector" % "0.7.1")
+  )
+)

project/build.properties

@@ -0,0 +1 @@
+sbt.version=0.13.9

project/plugins.sbt

@@ -0,0 +1 @@
+addSbtPlugin("org.scalaexercises" % "sbt-exercise" % "0.0.0-SNAPSHOT", "0.13", "2.10")

src/main/resources/scala-exercises/library.47

@@ -0,0 +1,3 @@
+defaultLib.Library_cats$1$
+defaultLib.Library_shapeless$1$
+defaultLib.Library_stdlib$1$

src/main/scala/shapeless/ArityExercises.scala

@@ -0,0 +1,44 @@
+package shapelessex
+
+import org.scalatest._
+import shapeless._
+import ops.hlist._
+
+/** == Facilities for abstracting over arity ==
+  *
+  * Conversions between tuples and `HList`'s, and between ordinary Scala functions of arbitrary arity and functions which
+  * take a single corresponding `HList` argument allow higher order functions to abstract over the arity of the functions
+  * and values they are passed
+  * {{{
+  * import syntax.std.function._
+  * import ops.function._
+  *
+  * def applyProduct[P <: Product, F, L <: HList, R](p: P)(f: F)
+  * (implicit gen: Generic.Aux[P, L], fp: FnToProduct.Aux[F, L => R]) =
+  * f.toProduct(gen.to(p))
+  * }}}
+  *
+  * @param name arity
+  */
+object ArityExercises extends FlatSpec with Matchers with exercise.Section {
+
+  import syntax.std.function._
+  import ops.function._
+
+  object Helper {
+
+    def applyProduct[P <: Product, F, L <: HList, R](p: P)(f: F)(implicit gen: Generic.Aux[P, L], fp: FnToProduct.Aux[F, L ⇒ R]) =
+      f.toProduct(gen.to(p))
+
+  }
+
+  import Helper._
+
+  /** Abstracting over arity
+    */
+  def arityTest(res0: Int, res1: Int) = {
+    applyProduct(1, 2)((_: Int) + (_: Int)) should be(res0)
+    applyProduct(1, 2, 3)((_: Int) * (_: Int) * (_: Int)) should be(res1)
+  }
+
+}

src/main/scala/shapeless/AutoTypeClassExercises.scala

@@ -0,0 +1,171 @@
+package shapelessex
+
+import org.scalatest._
+import shapeless._
+
+trait Monoid[T] {
+  def zero: T
+  def append(a: T, b: T): T
+}
+
+object Monoid extends ProductTypeClassCompanion[Monoid] {
+  def mzero[T](implicit mt: Monoid[T]) = mt.zero
+
+  implicit def booleanMonoid: Monoid[Boolean] = new Monoid[Boolean] {
+    def zero = false
+    def append(a: Boolean, b: Boolean) = a || b
+  }
+
+  implicit def intMonoid: Monoid[Int] = new Monoid[Int] {
+    def zero = 0
+    def append(a: Int, b: Int) = a + b
+  }
+
+  implicit def doubleMonoid: Monoid[Double] = new Monoid[Double] {
+    def zero = 0.0
+    def append(a: Double, b: Double) = a + b
+  }
+
+  implicit def stringMonoid: Monoid[String] = new Monoid[String] {
+    def zero = ""
+    def append(a: String, b: String) = a + b
+  }
+
+  object typeClass extends ProductTypeClass[Monoid] {
+    def emptyProduct = new Monoid[HNil] {
+      def zero = HNil
+      def append(a: HNil, b: HNil) = HNil
+    }
+
+    def product[F, T <: HList](mh: Monoid[F], mt: Monoid[T]) = new Monoid[F :: T] {
+      def zero = mh.zero :: mt.zero
+      def append(a: F :: T, b: F :: T) = mh.append(a.head, b.head) :: mt.append(a.tail, b.tail)
+    }
+
+    def project[F, G](instance: ⇒ Monoid[G], to: F ⇒ G, from: G ⇒ F) = new Monoid[F] {
+      def zero = from(instance.zero)
+      def append(a: F, b: F) = from(instance.append(to(a), to(b)))
+    }
+  }
+}
+
+trait MonoidSyntax[T] {
+  def |+|(b: T): T
+}
+
+object MonoidSyntax {
+  implicit def monoidSyntax[T](a: T)(implicit mt: Monoid[T]): MonoidSyntax[T] = new MonoidSyntax[T] {
+    def |+|(b: T) = mt.append(a, b)
+  }
+}
+
+/** == Automatic type class instance derivation ==
+  *
+  * Based on and extending `Generic` and `LabelledGeneric`, Lars Hupel ([[https://twitter.com/larsr_h @larsr_h]]) has contributed the `TypeClass`
+  * family of type classes, which provide automatic type class derivation facilities roughly equivalent to those available
+  * with GHC as described in [[http://dreixel.net/research/pdf/gdmh.pdf "A Generic Deriving Mechanism for Haskell"]].  There is a description of an
+  * earlier iteration of the Scala mechanism [[http://typelevel.org/blog/2013/06/24/deriving-instances-1.html here]], and examples of its use deriving `Show` and `Monoid`
+  * instances [[https://github.com/milessabin/shapeless/blob/master/examples/src/main/scala/shapeless/examples/shows.scala here]]
+  * and [[https://github.com/milessabin/shapeless/blob/master/examples/src/main/scala/shapeless/examples/monoids.scala here]] for labelled coproducts and unlabelled products respectively.
+  *
+  * For example, in the `Monoid` case, once the general deriving infrastructure for monoids is in place, instances are
+  * automatically available for arbitrary case classes without any additional boilerplate
+  *
+  * {{{
+  * trait Monoid[T] {
+  * def zero: T
+  * def append(a: T, b: T): T
+  * }
+  *
+  * object Monoid extends ProductTypeClassCompanion[Monoid] {
+  * def mzero[T](implicit mt: Monoid[T]) = mt.zero
+  *
+  * implicit def booleanMonoid: Monoid[Boolean] = new Monoid[Boolean] {
+  * def zero = false
+  * def append(a: Boolean, b: Boolean) = a || b
+  * }
+  *
+  * implicit def intMonoid: Monoid[Int] = new Monoid[Int] {
+  * def zero = 0
+  * def append(a: Int, b: Int) = a+b
+  * }
+  *
+  * implicit def doubleMonoid: Monoid[Double] = new Monoid[Double] {
+  * def zero = 0.0
+  * def append(a: Double, b: Double) = a+b
+  * }
+  *
+  * implicit def stringMonoid: Monoid[String] = new Monoid[String] {
+  * def zero = ""
+  * def append(a: String, b: String) = a+b
+  * }
+  *
+  * object typeClass extends ProductTypeClass[Monoid] {
+  * def emptyProduct = new Monoid[HNil] {
+  * def zero = HNil
+  * def append(a: HNil, b: HNil) = HNil
+  * }
+  *
+  * def product[F, T <: HList](mh: Monoid[F], mt: Monoid[T]) = new Monoid[F :: T] {
+  * def zero = mh.zero :: mt.zero
+  * def append(a: F :: T, b: F :: T) = mh.append(a.head, b.head) :: mt.append(a.tail, b.tail)
+  * }
+  *
+  * def project[F, G](instance: => Monoid[G], to: F => G, from: G => F) = new Monoid[F] {
+  * def zero = from(instance.zero)
+  * def append(a: F, b: F) = from(instance.append(to(a), to(b)))
+  * }
+  * }
+  * }
+  *
+  * trait MonoidSyntax[T] {
+  * def |+|(b: T): T
+  * }
+  *
+  * object MonoidSyntax {
+  * implicit def monoidSyntax[T](a: T)(implicit mt: Monoid[T]): MonoidSyntax[T] = new MonoidSyntax[T] {
+  * def |+|(b: T) = mt.append(a, b)
+  * }
+  * }
+  * }}}
+  * The [[https://github.com/typelevel/shapeless-contrib shapeless-contrib]] project also contains automatically derived type class instances for
+  * [[https://github.com/typelevel/shapeless-contrib/blob/master/scalaz/main/scala/typeclass.scala Scalaz]],
+  * [[https://github.com/typelevel/shapeless-contrib/blob/master/spire/main/scala/typeclass.scala Spire]] and
+  * [[https://github.com/typelevel/shapeless-contrib/blob/master/scalacheck/main/scala/package.scala Scalacheck]].
+  *
+  * @param name auto_typeclass_derivation
+  *
+  */
+object AutoTypeClassExercises extends FlatSpec with Matchers with exercise.Section {
+
+  object Helper {
+
+    // A pair of arbitrary case classes
+    case class Foo(i: Int, s: String)
+    case class Bar(b: Boolean, s: String, d: Double)
+  }
+
+  import Helper._
+
+  /** {{{
+    *
+    * // A pair of arbitrary case classes
+    * case class Foo(i : Int, s : String)
+    * case class Bar(b : Boolean, s : String, d : Double)
+    *
+    * }}}
+    */
+  def monoidDerivation(res0: Int, res1: String, res2: Boolean, res3: String, res4: Double) = {
+
+    import MonoidSyntax._
+    import Monoid.typeClass._
+
+    val fooCombined = Foo(13, "foo") |+| Foo(23, "bar")
+    fooCombined should be(Foo(res0, res1))
+
+    val barCombined = Bar(true, "foo", 1.0) |+| Bar(false, "bar", 3.0)
+    barCombined should be(Bar(res2, res3, res4))
+
+  }
+
+}

src/main/scala/shapeless/CoproductExercises.scala

@@ -0,0 +1,72 @@
+package shapelessex
+
+import org.scalatest._
+import shapeless._
+
+/** == Coproducts and discriminated unions ==
+  *
+  * shapeless has a Coproduct type, a generalization of Scala's `Either` to an arbitrary number of choices. Currently it
+  * exists primarily to support `Generic` (see the next section), but will be expanded analogously to `HList` in later
+  * releases. Currently `Coproduct` supports mapping, selection and unification
+  *
+  * @param name coproducts
+  */
+object CoproductExercises extends FlatSpec with Matchers with exercise.Section {
+
+  object Helper {
+    type ISB = Int :+: String :+: Boolean :+: CNil
+
+    object sizeM extends Poly1 {
+      implicit def caseInt = at[Int](i ⇒ (i, i))
+      implicit def caseString = at[String](s ⇒ (s, s.length))
+      implicit def caseBoolean = at[Boolean](b ⇒ (b, 1))
+    }
+
+    val isb = Coproduct[ISB]("foo")
+  }
+
+  import Helper._
+
+  /** {{{
+    * type ISB = Int :+: String :+: Boolean :+: CNil
+    *
+    * val isb = Coproduct[ISB]("foo")
+    * }}}
+    */
+  def selection(res0: Option[Int], res1: Option[String]) = {
+    isb.select[Int] should be(res0)
+
+    isb.select[String] should be(res1)
+  }
+
+  /** Coproduct also supports mapping given a polymorphic function such as
+    * {{{
+    * object sizeM extends Poly1 {
+    * implicit def caseInt = at[Int](i => (i, i))
+    * implicit def caseString = at[String](s => (s, s.length))
+    * implicit def caseBoolean = at[Boolean](b => (b, 1))
+    * }
+    * }}}
+    */
+  def mapping(res0: Option[(String, Int)]) = {
+    val m = isb map sizeM
+
+    m.select[(String, Int)] should be(res0)
+  }
+
+  /** In the same way that adding labels To the elements of an HList gives us a record,
+    * adding labels to the elements of a Coproduct gives us a discriminated union.
+    */
+  def unionE(res0: Option[Int], res1: Option[String], res2: Option[Boolean]) = {
+    import record._, union._, syntax.singleton._
+
+    type U = Union.`'i -> String, 's -> String, 'b -> Boolean`.T
+
+    val u = Coproduct[U]('s ->> "foo") // Inject a String into the union at label 's
+
+    u.get('i) should be(res0)
+    u.get('s) should be(res1)
+    u.get('b) should be(res2)
+  }
+
+}