Derive new type from case class using Shapeless

Question

Let's say I have

case class User(id: Long, name: String, age: Long, email: Option[String])

Is there a way I can create let's say

type UpdateUser = ???.???[User] // update user has same fields as User except all are optional

that I can then use as

UpdateUser(name = Some("foo"), email = Some("foo@bar.com"))

so basically mapping types

Long         :: String         :: Long         :: Option[String] 
->
Option[Long] :: Option[String] :: Option[Long] :: Option[String]

So once again, question is, is there way (i.e. using shapeless) to create such derived case class with such fields (without writing macro to do that.)

Case clases are just HLists. Can we create a new type based on some type of HList?

Possible duplicate of http://stackoverflow.com/questions/12705309/scala-case-class-inheritance — Viktor K., May 20 '16 at 13:17
It is not duplicate of that. Question is, if we can, and how, using shapeless, derive new case class, without explicitly writing macro. I think down-voting it is unjustified. — fromscalatohaskell, May 20 '16 at 16:06

lmm · Accepted Answer · 2016-12-15T07:12:51.613

You can't generate a de novo concrete type, except perhaps with a macro annotation. What you can do is use a typeclass to derive a generic type that has the transformed shape that you want.

import shapeless._, labelled._

trait RecordAsOption[L] {
  type Out <: HList
}
object RecordAsOption {
  def apply[L](implicit recordAsOption: RecordAsOption[L])
      : Aux[L, recordAsOption.Out] =
    recordAsOption
  type Aux[L, Out0 <: HList] = RecordAsOption[L] { type Out = Out0 }
  implicit def hnilRecordAsOption[L <: HNil]: Aux[L, HNil] =
    new RecordAsOption[L] {
      type Out = HNil
      def apply(l: L) = HNil
    }

  implicit def hconsRecordAsOption[K, V, T <: HList](
      implicit tail: RecordAsOption[T])
      : Aux[FieldType[K, V] :: T, FieldType[K, Option[V]] :: tail.Out] =
    new RecordAsOption[FieldType[K, V] :: T] {
      type Out = FieldType[K, Option[V]] :: tail.Out
    }

  implicit def genericRecordAsOption[T, R](
    implicit lg: LabelledGeneric.Aux[T, R], roa: RecordAsOption[T])
      : Aux[T, roa.Out] =
    new RecordAsOption[T] {
      type Out = roa.Out
    }
}

case class User(id: Long, name: String, age: Long, email: Option[String])
val genericUserUpdate = RecordAsOption[User]
type GenericUserUpdate = genericUserUpdate.Out

You probably want to add some functionality to the RecordAsOption typeclass (given the name, probably a lens-like method that applies the delta represented by the options to a value of type L), since as it stands the type is kind of useless. The record representation isn't quite as nice as a case class in some respects, but it can interoperate nicely with other shapeless-based things (e.g. it would be easy to use similar techniques to spray-json-shapeless to deserialize JSON to a GenericUserUpdate)

A mistake; I was originally doing the `LabelledGeneric` part separately, but then I moved it into the typeclass. — lmm, Dec 15 '16 at 07:13

Derive new type from case class using Shapeless

1 Answers1