objetos - scala ejemplos

Scala-Ejemplo de clase de tipo. ¿Cómo explicar los beneficios?

Question

Así que le mostré a un compañero de trabajo / amigo un ejemplo del patrón de clase de letra en Scala. Se parece a esto:

case class Song(name: String, artist: String)
case class Address(street: String, number: Int)

trait LabelMaker[T] {
  def output(t: T): String
}

object LabelMaker {
  implicit object addressLabelMaker extends LabelMaker[Address] {
    def output(address: Address) = {
      address.number + " " + address.street + " street"
    }
  }
  implicit object songLabelMaker extends LabelMaker[Song] {
    def output(song: Song) = {
      song.artist + " - " + song.name
    }
  }
  def label[T : LabelMaker](t: T) = implicitly[LabelMaker[T]].output(t)
}

Que se puede usar así:

import LabelMaker._
println(label(new Song("Hey Ya", "Outkast"))) // Outkast - Hey Ya
println(label(new Address("Smithsonian", 273))) // 273 Smithsonian street

No es el mejor ejemplo, y en retrospectiva desearía encontrar una mejor. Al mostrarlo, respondió con un contraejemplo y preguntó qué beneficios realmente aporta el patrón de clase de tipo a la tabla:

case class Song(name: String, artist: String)
case class Address(street: String, number: Int)

object LabelMaker {

    def label(address: Address) = {
        address.number + " " + address.street + " street"
    }

    def label(song: Song) = {
        song.artist + " - " + song.name
    }
}

import LabelMaker._
println(label(new Song("Hey Ya", "Outkast"))) // Outkast - Hey Ya
println(label(new Address("Smithsonian", 273))) // 273 Smithsonian street

Luché para responder adecuadamente, y me hizo darme cuenta de que no entiendo muy bien las ganancias obtenidas al 100%. Entiendo su implementación y beneficios muy localizados cuando alguien más los usa, pero explicarlos de manera sucinta es bastante difícil. ¿Alguien puede ayudarme? Y quizás extienda mi ejemplo para mostrar realmente los beneficios.

Answer 1

Las clases de tipos capturan la noción de extensibilidad retroactiva . Con las sobrecargas de métodos estáticos, debe definirlos todos a la vez en un solo lugar, pero con las clases de tipos puede definir nuevas instancias cada vez que desee para cualquier tipo nuevo en cualquier módulo. Por ej.

object LabelMaker {
  // ... your original cases here ...
  def label[T : LabelMaker](t: T) = implicitly[LabelMaker[T]].output(t)
}

// somewhere in future
object SomeModule {
  import LabelMaker._

  case class Car(title: String)

  implicit object carLabelMaker extends LabelMaker[Car] {
    def output(car: Car) = car.title
  }  
}

object Main extends App {
  import LabelMaker._
  import SomeModule._

  println(label(Car("Mustang")))
}

Answer 2

Escriba inferencia y composición de clases de tipos:

implicit def tupleLabel[A: LabelMaker,B: LabelMaker] = new LabelMaker[(A,B)]{
  def output(tuple: (A,B)) = 
    implicitly[Label[A]].label(tuple._1) + " and " + implicitly[Label[B]].label(tuple._2)
}

Esto es obviamente útil y no funcionará en la versión de Java de su compañero de trabajo.