FPStyle.scala

package example

object FPStyle {

  trait Show[T] {
    def show(t: T): String
  }

  object Show {

    def apply[T](implicit instance: Show[T]): Show[T] = instance

  }

  case class MaClassFP(value1: String, value2: String)

  case class PasMaClassFP(value1: String, value2: String)

  def maMethode[T: Show](t: T): String = {
    Show[T].show(t)
  }

  implicit object ShowMaClassFP extends Show[MaClassFP] {
    override def show(t: MaClassFP): String =
      s"""{"value1": ${t.value1}, "value2": ${t.value2}}"""
  }

  implicit object ShowPasMaClassFP extends Show[PasMaClassFP] {
    override def show(t: PasMaClassFP): String =
      s"""{"value1": ${t.value1}, "value2": ${t.value2}}"""
  }

  val maClassFP = MaClassFP("test1", "test2")
  val pasMaClassFP = PasMaClassFP("test3", "test4")


}

MagnoliaStyle.scala

package example

import example.MagnoliaStyle.Show
import magnolia.{ CaseClass, Magnolia, SealedTrait }

object MagnoliaStyle {

  trait Show[T] {
    def show(t: T): String
  }

  object Show {

    def apply[T](implicit instance: Show[T]): Show[T] = instance

  }

  case class MaClassMagnolia(value1: String, value2: Int)

  case class PasMaClassMagnolia(value1: String, value2: Boolean)

  def maMethode[T: Show](t: T): String = {
    Show[T].show(t)
  }

  implicit object ShowString extends Show[String] {
    override def show(t: String): String =
      s""""$t""""
  }

  implicit object ShowInt extends Show[Int] {
    override def show(t: Int): String =
      s"$t"
  }

  implicit object ShowBoolean extends Show[Boolean] {
    override def show(t: Boolean): String =
      s"$t"
  }

  val maClassMagnolia = MaClassMagnolia("test1", 1)
  val pasMaClassMagnolia = PasMaClassMagnolia("test3", true)


}

object ShowDerivation {
  type Typeclass[T] = Show[T]

  def combine[T](ctx: CaseClass[Typeclass, T]): Typeclass[T] = (t: T) => ctx.parameters.map { p =>
    s"${p.label}=${p.typeclass.show(p.dereference(t))}"
  }.mkString("{", ",", "}")

  def dispatch[T](sealedTrait: SealedTrait[Typeclass, T]): Typeclass[T] = (t: T) => sealedTrait.dispatch(t) { sub =>
    sub.typeclass.show(sub.cast(t))
  }


  implicit def gen[T]: Typeclass[T] = macro Magnolia.gen[T]
}



// import $ivy.`com.propensive::magnolia:0.10.0`

OOPStyle.scala

package example

object OOPStyle {

  /**
    * OOP Style
    */
  trait Showable {
    def show: String
  }

  case class MaClasseOOP(value1: String, value2: String) extends Showable {

    def show: String =
      s"""{"value1": $value1, "value2": $value2}"""

  }


  case class PasMaClasseOOP(value1: String, value2: String)

  case class PasMaClasseOOPShowBridge(pasMaClasseOOP: PasMaClasseOOP) extends Showable {
    override def show: String = s"""{"value1": ${pasMaClasseOOP.value1}, "value2": ${pasMaClasseOOP.value2}}"""
  }


  def maMethode(t: Showable): String = t.show


  val showMaClass = maMethode(MaClasseOOP("test1", "test2"))

  // ça va fail
  val failShowPasMaClass = maMethode(PasMaClasseOOP("test1", "test2"))

  val showPasMaClass = maMethode(PasMaClasseOOPShowBridge(PasMaClasseOOP("test1", "test2")))


}