ADTEnum.scala

// Enum type based on Sum types (OR)
trait ADTEnum[A] {
  import play.api.data.mapping.json.Writes._
  import play.api.data.mapping.json.Rules._

  val list: Seq[A]

  def withName(name: String): Option[A] = {
    list.find(_.toString.toLowerCase == name.toLowerCase)
  }

  implicit val jsonReads: Rule[JsValue, A] = Rule.fromMapping {
    case JsString(str) =>
      withName(str) match {
        case Some(name) => Success(name)
        case None => Failure(Seq(ValidationError(s"error.unknownADTEnum")))
      }
    case _ => Failure(Seq(ValidationError(s"error.ADTEnumMustBeAString")))
  }

  implicit val jsonWrites: Write[A, JsString] = Write(a => JsString(a.toString))
}

Use:

sealed trait Dsp
object Dsp extends ADTEnum[Dsp] {
  case object AppNexus extends Dsp
  case object MediaMath extends Dsp
  val list = Seq(AppNexus, MediaMath)
}

def foo(dsp: Dsp) = dsp match {
  case Dsp.AppNexus => "foo"
  case Dsp.MediaMath => "bar"
}

Advantages over Enumeration:

• Better syntax: type is Dsp, a value is Dsp.AppNexus (no more "Enumeration.Value")
• Safe pattern matching with compiler warning if a case has been forgotten
• Automatic jsonWrites and jsonReads

Nice !

cool thanks, here is an implementation with Spray and Play Json marshalling (dependencies: play-json, spray-json) => https://gist.github.com/cyppan/edcda7e67c1551e0122c