Use shapeless to derive query string params from case class

This case well described Type Astronaut book : https://books.underscore.io/shapeless-guide/shapeless-guide.html#records-and-labelledgeneric.

So basically, you need to take a look at LabeledGeneric type class - which help with any product type (like case class) derivations.

In your case implementation might look like:

  import shapeless.{::, HList, HNil, LabelledGeneric, Lazy, Witness}
  import shapeless.labelled.FieldType

  trait Encoder[T] {
    def encode(value: T): String
  }

  object Encoder {
    def createEncoder[T](f: T => String): Encoder[T] = f(_)
    def apply[T](implicit encoder: Encoder[T]): Encoder[T] = encoder

    implicit val stringEncoder: Encoder[String] = createEncoder[String](identity)
    implicit val intEncoder: Encoder[Int] = createEncoder[Int](_.toString)
  }

  // Special encoder, which can encode product or object
  trait ObjectEncoder[T] extends Encoder[T] {
    final override def encode(value: T): String = {
      encodeObject(value).map{
        case (key, value) => s"$key=$value"
      }.mkString("&")
    }

    def encodeObject(t: T): Map[String, String]
  }

  object ObjectEncoder {
    def createEncoder[T](f: T => Map[String, String]): ObjectEncoder[T] = f(_)
    def apply[T](implicit encoder: ObjectEncoder[T]): ObjectEncoder[T] = encoder

    // This need to terminate derivation process
    implicit val hNilObjectEncoder: ObjectEncoder[HNil] = {
      ObjectEncoder.createEncoder(_ => Map.empty)
    }

    // Generate object encoder derivation
    implicit def hlistObjectEncoder[K <: Symbol, H, T <: HList]
    (implicit
     fieldWitness: Witness.Aux[K],
     headEncoder: Lazy[Encoder[H]],
     tailEncoder: ObjectEncoder[T]
    ): ObjectEncoder[FieldType[K, H] :: T] = {
      val fieldName: String = fieldWitness.value.name
      ObjectEncoder.createEncoder { hlist =>
        val headValue: String = headEncoder.value.encode(hlist.head)
        val head: Map[String, String] = List(fieldName -> headValue).toMap
        val tail: Map[String, String] = tailEncoder.encodeObject(hlist.tail)
        head ++ tail
      }
    }

    implicit def genericObjectEncoder[A, H]
    ( implicit
      generic: LabelledGeneric.Aux[A, H],
      hEncoder: Lazy[ObjectEncoder[H]]
    ): ObjectEncoder[A] = {
      ObjectEncoder.createEncoder { value =>
        val t = generic.to(value)
        hEncoder.value.encodeObject(t)
      }
    }
  }

  // Just syntactic sugar helpers
  object EncoderSyntax {
    implicit class EncodeOps[A](a: A) {
      def encode(implicit encoder: Encoder[A]): String = encoder.encode(a)
    }
  }

  def main(args: Array[String]): Unit = {
    import Encoder._
    import ObjectEncoder._
    import EncoderSyntax._

    case class Example(foo: String, bar: String)
    val example = Example("foo", "bar")
    println(example.encode)
  }

Which will produce next result:

foo=foo&bar=bar

Hope this helps!

I ended up solving this by modifying the typeclass to return a function which constructs the right string when applied. It's not perfect but I'm pretty sure it does the trick.

trait Encoder[T] {
  def encode(value: T): String => List[String]
}

object Encoder {
  def createEncoder[T](f: T => String): Encoder[T] = value => name => List(s"$name=${f(value)}")
  def apply[T](implicit encoder: Encoder[T]): Encoder[T] = encoder

  implicit val stringEncoder: Encoder[String] = createEncoder[String](identity)
  implicit val intEncoder: Encoder[Int] = createEncoder[Int](_.toString)
  implicit val boolEncoder: Encoder[Boolean] = createEncoder(_.toString)
  implicit def listEncoder[T](implicit encoder: Encoder[T]): Encoder[List[T]] =
    (list: List[T]) => (name: String) => list.zipWithIndex.map { case (value, index) => s"$name.${index + 1}=$value" }

  implicit def mapEncoder[T](implicit encoder: Encoder[T]): Encoder[Map[String, T]] =
    (map: Map[String, T]) =>
      (name: String) =>
        map.zipWithIndex.flatMap {
          case ((key, value), index) => List(s"$name.${index + 1}.Name=$key", s"$name.${index + 1}.Value=$value")
        }.toList
}

trait ObjectEncoder[T] extends Encoder[T] {
  final override def encode(value: T): String => List[String] =
    name => encodeObject(value).apply(name)

  def encodeObject(t: T): String => List[String]
}

object ObjectEncoder {
  def createEncoder[T](f: T => String => List[String]): ObjectEncoder[T] = new ObjectEncoder[T] {
    override def encodeObject(t: T): String => List[String] = name => f.apply(t).apply(name)
  }
  def apply[T](implicit encoder: ObjectEncoder[T]): ObjectEncoder[T] = encoder

  implicit val hNilObjectEncoder: ObjectEncoder[HNil] = createEncoder(_ => _ => List.empty)

  implicit def hlistObjectEncoder[K <: Symbol, H, T <: HList](
      implicit
      fieldWitness: Witness.Aux[K],
      headEncoder: Lazy[Encoder[H]],
      tailEncoder: ObjectEncoder[T]): ObjectEncoder[FieldType[K, H] :: T] = {
    val fieldName: String = fieldWitness.value.name

    createEncoder { hlist =>
      val head: String => List[String] = headEncoder.value.encode(hlist.head)
      val tail: String => List[String] = tailEncoder.encodeObject(hlist.tail)
      (name: String) =>
        head.apply(fieldName) ++ tail.apply(name)
    }
  }

  implicit def genericObjectEncoder[A, H](
      implicit
      generic: LabelledGeneric.Aux[A, H],
      hEncoder: Lazy[ObjectEncoder[H]]): ObjectEncoder[A] =
    ObjectEncoder.createEncoder { value =>
      val t = generic.to(value)
      hEncoder.value.encodeObject(t)
    }

  // Unfortunately we must apply the returned function with an empty string, the arg is used for formatting
  // each piece but is unecessary for the whole thing
  def encode[T](input: T)(implicit encoder: Encoder[T]) = encoder.encode(input).apply("").mkString("&")
}