Derivando circe Codec per una famiglia caso classe chiusa dove basamento tratto ha un (sigillato) Tipo di utente

Question

posso facilmente genericamente derivare un codec per una famiglia di classe cassa sigillata simili:

import io.circe._ 
import io.circe.generic.auto._ 

sealed trait Base 
case class X(x: Int) extends Base 
case class Y(y: Int) extends Base 

object Test extends App { 
    val encoded = Encoder[Base].apply(Y(1)) 
    val decoded = Decoder[Base].apply(encoded.hcursor) 
    println(decoded) // Right(Y(1)) 
} 

Tuttavia, se aggiungo un membro di tipo alla classe di base che non posso più farlo, anche se è delimitata da un tratto sigillato:

import io.circe._ 
import io.circe.generic.auto._ 

sealed trait Inner 
case class I1(i: Int) extends Inner 
case class I2(s: String) extends Inner 

sealed trait Base { type T <: Inner } 
case class X[S <: Inner](x: S) extends Base { final type T = S } 
case class Y[S <: Inner](y: S) extends Base { final type T = S } 

object Test extends App { 
    val encodedInner = Encoder[Inner].apply(I1(1)) 
    val decodedInner = Decoder[Inner].apply(encodedInner.hcursor) // Ok 
    println(decodedInner) // Right(I1(1)) 

    // Doesn't work: could not find implicit for Encoder[Base] etc 
    // val encoded = Encoder[Base].apply(Y(I1(1))) 
    // val decoded = Decoder[Base].apply(encoded.hcursor) 
    // println(decoded) 
} 

c'è un modo per ottenere ciò che voglio? In caso contrario, cosa posso cambiare per ottenere qualcosa di simile?

Answer 1

Il motivo principale per questo non funziona è perché si sta cercando di fare essenzialmente

Encoder[Base { type T }] 

da sé che tipo T è. È analogo aspettarsi che questa funzione si compili -

def foo[A] = implicitly[Encoder[List[A]]] 

È necessario perfezionare esplicitamente il tipo.

Un modo per avvicinarsi a questo è con il modello Aux. Non è possibile utilizzare il tipico type Aux[S] = Base { type T = S } dal momento che non fornirà il coprodotto quando si tenta di derivare l'istanza (le classi X e Y non possono estendersi da un alias di tipo). Invece, potremmo fare un giro intorno creando un altro tratto sigillato come Aux e le nostre classi di casi si estendono da quello.

Fino a quando tutte le classi case si estendono dalla Base.Aux invece che direttamente da Base, è possibile utilizzare il seguente, che gli abusi .asInstanceOf per placare il sistema di tipi.

sealed trait Inner 
case class I1(i: Int) extends Inner 
case class I2(s: String) extends Inner 

sealed trait Base { type T <: Inner } 
object Base { 
    sealed trait Aux[S <: Inner] extends Base { type T = S } 
    implicit val encoder: Encoder[Base] = { 
    semiauto.deriveEncoder[Base.Aux[Inner]].asInstanceOf[Encoder[Base]] 
    } 
    implicit val decoder: Decoder[Base] = { 
    semiauto.deriveDecoder[Base.Aux[Inner]].asInstanceOf[Decoder[Base]] 
    } 
} 

val encoded = Encoder[Base].apply(Y(I1(1))) 
val decoded = Decoder[Base].apply(encoded.hcursor) 

Si noti che molto dipende da come si stanno effettivamente utilizzando i tipi. Immagino che non ti affidi chiamando lo Encoder[Base] direttamente e preferisci usare lo import io.circe.syntax._ e chiamare il metodo di estensione .asJson. In tal caso, potresti essere in grado di fare affidamento su un'istanza Encoder[Base.Aux[S]] che verrebbe dedotta in base al valore codificato/decodificato. Qualcosa come il seguente potrebbe essere sufficiente per il tuo caso d'uso senza ricorrere agli hack .asInstanceOf.

implicit def encoder[S <: Inner : Encoder]: Encoder[Base.Aux[S]] = { 
    semiauto.deriveEncoder 
} 

Di nuovo, tutto dipende da come si utilizzano le istanze. Sono scettico sul fatto che tu abbia effettivamente bisogno di un membro di tipo in Base, le cose sarebbero più semplici se lo spostassi su un parametro generico in modo che il deriver potesse capire il coprodotto per te.