Typeclass derivation case

[NPCRUS]

Hello folks, I have following type class hierarchy and use case. There are http request query params, which are represented as Seq[(String, String)], where first string of tuple represents a key and second represents value of a query parameter. My goal is to parse list of query parameters into arbitrary case class:

trait FilterExtractor[T] {
  def extract(input: Seq[(String, String)]): Either[String, T]
}

Parsing into case class only possible in a context of key being available, but at some point I need to parse value of query parameter into a type for example ?a=43 so "43" into Int, for this I have a separate typeclass:

trait ValueExtractor[T] {
  def extract(input: Seq[String]): Either[String, T]
}
object ValueExtractor {
  // givens for simple types
}

input here is a sequence, because you could have multiple values per key.
My derivation looks like this:

object FilterExtractor extends ProductDerivation[FilterExtractor] {
  private type StringEither[T] = Either[String, T]

  inline def join[DerivationType <: Product : ProductReflection]: FilterExtractor[DerivationType] =
    input =>
      constructWith[StringEither](
        [MonadicTypeIn, MonadicTypeOut] => _.flatMap,
        [MonadicType] => Right[String, MonadicType](_),
        [FieldType] => context => {
          val valuesByKey = input.filter(_._1 == label.s).map(_._2)
          ???
        }
      )
}

And where implementation is missing now starts my question, how can i produce result of FilterExtractor.extract using different type class for FieldType:

1. summonInline[FieldExtractor[FieldType]].extract(valuesByKey) but at the callsite FieldType type is not concrete, so it cannot find a given
2. define a private (inline) given that will convert presentValueExtractor for type T into FilterExtractor, so that I can just use context:

private given [T: ValueExtractor]: FilterExtractor[T] = input => summon[ValueExtractor[T]].extract(input.map(_._2))
...
context.extract(valuesByKey)

both inline and not inline variants throw same error:

No given instance of type de.spendit.portal.FilterExtractor[Int] was found.
I found:

    de.spendit.portal.FilterExtractor.given_FilterExtractor_T[Int](
      de.spendit.portal.ValueExtractor.given_ValueExtractor_Int)

But given instance given_FilterExtractor_T in object FilterExtractor does not match type

3. Just define FilterExtractor for simple types instead of ValueExtractor. This option I left as a fallback, because I think it's kinda wrong from logical perspective to discard ValueExtractor.
   Are there any other options? Is my thinking about type classes wrong? Or is it strange Scala compiler behaviour in case 2?
   Thanks in advance for answers

[NPCRUS]

relates to #20, it seems impossible to summonInline[Typeclass[T]] where T is a type parameter of polymorphic lambda

[propensive]

Issue #20 does make it impossible to summon a typeclass parameterized on a polymorphic type parameter, but I hope there's some workaround possible for that.

In the meantime, there is one possibility which might work. You could define a combined typeclass:

object FilterAndValueExtractor:
  given combined[T]: FilterAndValueExtractor[T](using filter: FilterExtractor[T], value: ValueExtractor[T]) =
    new FilterAndValueExtractor(filter, value)
    
class FilterAndValueExtractor[T](val filter: FilterExtractor[T], val value: ValueExtractor[T])

and then implementing generic derivation on FilterAndValueExtractor, which will give you access to both varieties of Extractor.

Then, you can provide an implementation of derived for FilterExtractor which looks something like this:

object FilterExtractor:
  inline given derived[T]: FilterExtractor[T] = summonInline[FilterAndValueExtractor[T]].filter

[propensive]

Ok, I misunderstood that detail.

Would it be possible to derive a type representing a FilterExtractor or a ValueExtractor? You could implement it with something along the lines of:

object FilterOrValueExtractor:
  given derived[T]: FilterOrValueExtractor[T] =
    compiletime.summonFrom:
      case extractor: ValueExtractor[T]  => FilterOrValueExtractor(extractor)
      case _                             => Deriver.derived[T]

object Deriver extends Derivation[FilterOrValueExtractor]:
  inline def join = // etc

object FilterExtractor:
  transparent inline given derived[T] = FilterOrValueExtractor.derived[T] match
    case extractor: FilterExtractor[T] => extractor

[NPCRUS]

i think we still have a missunderstanding, what i want is this:

object FilterExtractor extends ProductDerivation[FilterExtractor] {
  private type StringEither[T] = Either[String, T]

  inline def join[DerivationType <: Product : ProductReflection]: FilterExtractor[DerivationType] =
    input =>
      constructWith[StringEither](
        [MonadicTypeIn, MonadicTypeOut] => _.flatMap,
        [MonadicType] => Right[String, MonadicType](_),
        [FieldType] => context => {
          val valuesByKey = input.filter(_._1 == label.s).map(_._2)
          summonInline[ValueExtractor[FieldType]].extract(valuesByKey)
        }
      )
}

so when having case class case class Test(a: Int) and when constructing a value for field a i want to use ValueExtractor[Int] instead of context: FilterExtractor[Int]

[propensive]

No, I think this is consistent, but the limitation of #20 means we have to think about the problem differently...

So in general when you want a FilterExtractor for one of the fields of type FieldType within the full nested tree structure, there are three possibilities:

1. you already have a FilterExtractor[FieldType] because it's defined somewhere in scope
2. you have a ValueExtractor[FieldType] but not a FilterExtractor[FieldType]
3. you don't have either, but FieldType is a Product, so you can derive a FilterExtractor[FieldType]

But (1) and (3) are the same thing: we have one already or we can produce one on demand. So those are the two cases in the summonFrom. And thinking about this some more, the solution might be even simpler than I suggested at first:

1. Create a new derivation object for FilterExtractor that isn't the companion object itself, and write the derivation as if FilterExtractor always exists, and without reference to ValueExtractor.
2. Define an inline def derived in the FilterExtractor companion implemented using a summonFrom that handles the cases above in the order you want.

[NPCRUS]

surprisingly just a simple given conversion started working:

given [T: ValueExtractor]: FilterExtractor[T] = input => summon[ValueExtractor[T]].extract(input.map(_._2)

[propensive]

Great! That's actually much easier. On Scala 3.6, you can replace summon[ValueExtractor[T]] with just T.

[propensive]

One disadvantage is that this probably comes with some runtime penalty, and also a compiletime penalty if your derivations are complex enough.