在Scala中，如何将隐式转换应用于集合的子类型？

Question

I am trying to convert a list of objects to json using argonaut. The list contains a list of validation errors of varying type. For example it can contain an instance of ' MissingParameter ' or, ' InvalidParameter ' or any other type. I have defined EncodeJson (argonaut) codecs for both classes mentioned above. Is there any way I can convert a list of the above types to json using argonaut? I mean, can I achieve the following?

List(new MissingParameter("name"), new InvalidParameter("email")).asJson

Answer 1

The solution by Feyyaz seems to be the best solution possible. Just to avoid pattern matching every possible subclass, I am defining a contract in the parent so every subclass must provide an encoder. Not sure if it's perfect, but it does what I expect. I hope it helps someone who is looking for a similar solution.

import argonaut._, Argonaut._
import scala.collection.TraversableLike

trait HasEncoder[T <: HasEncoder[T]] { self: T =>
  def encoder: EncodeJson[T]
  lazy val json = encoder.encode(self)
}

object HasEncoder {
  implicit def listToRichHasEncoderList[A <: HasEncoder[_], Repr](coll: TraversableLike[A, Repr]): RichHasEncoderList[A, Repr] = new RichHasEncoderList[A, Repr](coll)
}

class RichHasEncoderList[A <: HasEncoder[_], Repr](coll: TraversableLike[A, Repr]) {
  lazy val json = jArray(coll.toList.map(_.json))
} 

In the above solution, argonaut expects a list to construct a json array(jArray), so, I had to accept anything that's traversable and convert it to a list. I am not sure if I can improve that part.

And a test case(Make sure to import the package where the above code resides so that the implicit 'json' value will be available on the list):

import argonaut._, Argonaut._
import org.scalatest.{Matchers, FlatSpec}

/**
  * Created by jamesanto on 12/17/15.
  */
class HasEncoderTest extends FlatSpec with Matchers {

  case class MissingParameter(name: String) extends HasEncoder[MissingParameter] {
    override def encoder: EncodeJson[MissingParameter] = casecodec1(MissingParameter.apply, MissingParameter.unapply)("name")
  }

  case class InvalidParameter(name: String, expected: String, actual: String) extends HasEncoder[InvalidParameter] {
    override def encoder: EncodeJson[InvalidParameter] = casecodec3(InvalidParameter.apply, InvalidParameter.unapply)("name", "expected", "actual")
  }

  it should "encode list of objects of classes that extend HasEncoder" in {
    val list = List(MissingParameter("email"), InvalidParameter("dob", "DOB in yyyy/MM/dd format", "10/10/1985"))
    list.json.nospaces should be ("""[{"name":"email"},{"name":"dob","expected":"DOB in yyyy/MM/dd format","actual":"10/10/1985"}]""")
  }
}

Answer 2

I haven't used argonaut, but I guess the problem here is a general issue. The type of the list here is List[Product with Serializable] . And the compiler won't know how to serialize it to Json.

I would suggest you to create a Parameter trait, extend the classes with it, and write a serializer for Parameter that checks all the types with pattern matching:

Note: I'm using play-json library, you should adapt it to argonaut.

import play.api.libs.json.{Writes, JsValue, Json}
import play.api.libs.json.Writes._

trait Parameter

case class MissingParameter (paramName: String) extends Parameter

case class InvalidParameter (paramName: String) extends Parameter

implicit val writes1 = Json.writes[MissingParameter]
implicit val writes2 = Json.writes[InvalidParameter]

implicit val implicitParamWrites = new Writes[Parameter] {
  def writes(param: Parameter): JsValue = {
    param match {
      case missing: MissingParameter => Json.toJson(missing)
      case invalid: InvalidParameter => Json.toJson(invalid)
    }
  }
}

val list: List[Parameter] = List( MissingParameter("p1"), InvalidParameter("i1") )

Json.toJson(list)