Scala3 enum support

[jtjeferreira]

Hi!

First of all, thanks for this nice library!

I was trying to use it with an enum like this:

import decisions4s.*

enum Foo {
  case Bar, Baz
}
object Foo {
  //Does not compile if commented
  implicit val literalShow: LiteralShow[Foo] = _.toString
}

case class Input[F[_]](
    numOfApprovals: F[Int],
    isTargetBranchProtected: F[Boolean],
    authorIsAdmin: F[Boolean],
    foo: F[Foo]
) derives HKD

case class Output[F[_]](
    allowMerging: F[Boolean],
    notifyUnusualAction: F[Boolean],
) derives HKD

def rules: List[Rule[Input, Output]] = List(
  // Unprotected branch requires 1 approval
  Rule(
    matching = Input(
      numOfApprovals = it > 0,
      isTargetBranchProtected = it.isFalse,
      authorIsAdmin = it.catchAll,
      foo = it.equalsTo(Foo.Bar),
    ),
    output = Output(allowMerging = true, notifyUnusualAction = false),
  ),
  // Nothing can be merged otherwise
  Rule.default(
    Output(allowMerging = false, notifyUnusualAction = false),
  ),
)

but I get an error

No given instance of type decisions4s.LiteralShow[Playground.Foo] was found for parameter x$2 of method equalsTo in object it.
I found:

    decisions4s.LiteralShow.product[T](
      shapeless3.deriving.K0.mkProductInstances[decisions4s.LiteralShow, T](
        /* missing */summon[scala.deriving².Mirror.Product of T]),
    ???)

[jtjeferreira]

adding

given [T <: scala.reflect.Enum]: LiteralShow[T] = _.toString

fixes the issue, but I wonder if we should support Mirror.Sum besides Mirror.Product

[Krever]

Hey, thanks fo feedback! TBH I've run into it myself a couple of times but never thought of fixing it properly out of inertia and fact that adding explicit given is very low effort. But I would definitely like to have it fixed.

I wonder if we should support Mirror.Sum besides Mirror.Product

Thats a good question. The answer is probably "yes", but with a caveat: I think I made a mistake initially making LiteralShow.product a given. My current opinion on derivation is that explicit single-level derivation (through derives) is the only sane way to do it. Another caveat is that currently it relies on shapeless-3 and Im not sure if its worth it (doing it based on pure mirrors might be simpler)

So while I would like to have sum support for derives it requires a bit more work to change current support for product. Hence, we could add support for raw enums first and handle generic sums separately. Or we can do two at once 🤷

For direct enums support, I thing going with automatic instance availability, as you proposed (given [T <: scala.reflect.Enum]: LiteralShow[T]) would make sense if not the fact that product cases still inherit the Enum as visible here. And we want better (labeled) support for products.

So the bottom line is:

1. We can add support for sums but it should not be a given
2. We probably should refactor current support for product (unless there is a good reason to keep current impl which I forgot)
3. We could provide automatic support (given) for enums composed of only case objects, but this might be slightly complicated

I'm happy to do it myself in a free moment but I'm equally happy to assist with a PR if you would like to give it a shot. Let me know if you're interested :)