Ereditarietà della classe case Scala

Ho un'applicazione basata su Squeryl. Definisco i miei modelli come classi case, soprattutto perché trovo conveniente avere metodi di copia.

Ho due modelli strettamente correlati. I campi sono gli stessi, molte operazioni sono in comune e devono essere memorizzate nella stessa tabella DB. Ma c'è un comportamento che ha senso solo in uno dei due casi, o che ha senso in entrambi i casi ma è diverso.

Finora ho utilizzato una sola classe case, con un flag che distingue il tipo di modello, e tutti i metodi che differiscono in base al tipo di modello iniziano con un if. Questo è fastidioso e non del tutto sicuro per i tipi.

Quello che vorrei fare è fattorizzare il comportamento e i campi comuni in una classe caso antenato e far ereditare i due modelli effettivi da esso. Ma, per quanto ne so, l'ereditarietà da classi case è disapprovata in Scala, ed è persino proibita se la sottoclasse è essa stessa una classe case (non il mio caso).

Quali sono i problemi e le insidie ​​di cui dovrei essere consapevole nell'ereditare da una classe case? Ha senso nel mio caso farlo?

Il mio modo preferito per evitare l'ereditarietà della classe case senza duplicazione del codice è piuttosto ovvio: creare una classe base comune (astratta):

abstract class Person {
  def name: String
  def age: Int
  // address and other properties
  // methods (ideally only accessors since it is a case class)
}

case class Employer(val name: String, val age: Int, val taxno: Int)
    extends Person

case class Employee(val name: String, val age: Int, val salary: Int)
    extends Person

Se vuoi essere più fine, raggruppa le proprietà in tratti individuali:

trait Identifiable { def name: String }
trait Locatable { def address: String }
// trait Ages { def age: Int }

case class Employer(val name: String, val address: String, val taxno: Int)
    extends Identifiable
    with    Locatable

case class Employee(val name: String, val address: String, val salary: Int)
    extends Identifiable
    with    Locatable

Poiché questo è un argomento interessante per molti, permettetemi di fare un po 'di luce qui.

Potresti seguire il seguente approccio:

// You can mark it as 'sealed'. Explained later.
sealed trait Person {
  def name: String
}

case class Employee(
  override val name: String,
  salary: Int
) extends Person

case class Tourist(
  override val name: String,
  bored: Boolean
) extends Person

Sì, devi duplicare i campi. Se non lo fai, semplicemente non sarebbe possibile implementare la corretta uguaglianza tra gli altri problemi .

Tuttavia, non è necessario duplicare metodi / funzioni.

Se la duplicazione di alcune proprietà è così importante per te, usa classi regolari, ma ricorda che non si adattano bene a FP.

In alternativa, puoi usare la composizione invece dell'ereditarietà:

case class Employee(
  person: Person,
  salary: Int
)

// In code:
val employee = ...
println(employee.person.name)

La composizione è una strategia valida e valida che dovresti anche considerare.

E nel caso ti chiedessi cosa significhi un tratto sigillato, è qualcosa che può essere esteso solo nello stesso file. Cioè, le due classi di casi precedenti devono essere nello stesso file. Ciò consente controlli esaustivi del compilatore:

val x = Employee(name = "Jack", salary = 50000)

x match {
  case Employee(name) => println(s"I'm $name!")
}

Fornisce un errore:

warning: match is not exhaustive!
missing combination            Tourist

Che è davvero utile. Ora non dimenticherai di occuparti degli altri tipi di Personpersone. Questo è essenzialmente ciò che fa la Optionclasse in Scala.

Se questo non ti interessa, puoi renderlo non sigillato e lanciare le classi del caso nei loro file. E forse vai con la composizione.

le classi case sono perfette per gli oggetti valore, cioè gli oggetti che non cambiano alcuna proprietà e possono essere confrontati con uguali.

Ma implementare la parità in presenza di eredità è piuttosto complicato. Considera due classi:

class Point(x : Int, y : Int)

e

class ColoredPoint( x : Int, y : Int, c : Color) extends Point

Quindi secondo la definizione il ColorPoint (1,4, rosso) dovrebbe essere uguale al punto (1,4) sono lo stesso punto dopotutto. Quindi ColorPoint (1,4, blu) dovrebbe essere uguale a Point (1,4), giusto? Ma ovviamente ColorPoint (1,4, rosso) non dovrebbe essere uguale a ColorPoint (1,4, blu), perché hanno colori diversi. Ecco fatto, una proprietà fondamentale della relazione di uguaglianza è interrotta.

aggiornare

Puoi utilizzare l'ereditarietà dai tratti risolvendo molti problemi come descritto in un'altra risposta. Un'alternativa ancora più flessibile è spesso quella di utilizzare classi di tipo. Vedi A cosa servono le classi di tipo in Scala? o http://www.youtube.com/watch?v=sVMES4RZF-8

In queste situazioni tendo a usare la composizione invece dell'ereditarietà, cioè

sealed trait IVehicle // tagging trait

case class Vehicle(color: String) extends IVehicle

case class Car(vehicle: Vehicle, doors: Int) extends IVehicle

val vehicle: IVehicle = ...

vehicle match {
  case Car(Vehicle(color), doors) => println(s"$color car with $doors doors")
  case Vehicle(color) => println(s"$color vehicle")
}

Ovviamente puoi usare una gerarchia e corrispondenze più sofisticate, ma si spera che questo ti dia un'idea. La chiave è sfruttare gli estrattori annidati forniti dalle classi case