shapeless automatic case class instances

Zero.scala

package zero { 

  trait Zero[A] {
    def zero: Option[A]
    def zeroN(s: String): Option[A] = zero
  }

  object Zero {

    def apply[A](implicit e: Zero[A]): Zero[A] = e

    def instance[A](z: Option[A]): Zero[A] = new Zero[A] {
      val zero = z
    }

    def instance[A](z: Option[A], v: String => Option[A]): Zero[A] = new Zero[A] {
      val zero = z
      override def zeroN(s:String) = v(s)
    }

    // 'basic' types
    implicit val zeroInt = instance(Some(0), x => Some(x.size))
    implicit val zeroString = instance(Some(""), x => Some(x))
    implicit val zeroOption = instance(Some(None))
    implicit val zeroBoolean = instance(Some(false), x => Some(x.size % 2 == 0))
    implicit val zeroList = instance(Some(Nil))

    // HLists
    implicit val zeroHNil: Zero[HNil] = instance(Some(HNil))

    implicit def zeroHList[S <: Symbol, H, T <: HList](
      implicit
        witness: Witness.Aux[S],
      zeroHead: Lazy[Zero[H]],
      zeroTail: Zero[T]
    ): Zero[FieldType[S,H] :: T] = {
      val fieldname = witness.value.name

      instance {
        for {
          h <- zeroHead.value.zeroN(fieldname)
          t <- zeroTail.zero
        } yield {
          field[S](h) :: t
        }
      }
    }

    // generic
    implicit def zeroGeneric[A, R <: HList](
      implicit gen: LabelledGeneric.Aux[A, R],
      enc: Lazy[Zero[R]]
    ): Zero[A] = instance{enc.value.zero.map{gen.from}}
  }

}