Compile-time conditional implicit (if fails, continue implicit search)

[adamw]

Is there a way to define an implicit value, but only if a compile-time condition is met, so that the implicit search continues (using lower-precedence values) if the condition is false?

This would be trivial if not for the second part: the inline/macro can simply report a compile-time error if the condition is false and be done with it. However, I'd like to define a special-case implicit for which a compile-time check needs to be done.

I've tried with transparent implicits, sth like:

enum MyCondition[T]:
  case Yes[T] extends MyCondition[T]
  case No[T] extends MyCondition[T]

transparent implicit inline def checkMyConditon[T]: MyCondition[T] = 
  /* macro which checks the condition based on T */

// the special-case implicit:
implicit inline def mySpecialImplicit[T](using MyCondition.Yes[T]) = 
  /* another macro */

However, despite being transparent, and despite returning the right sub-type from the macro implementation, the Yes implicit is never found.

Even a simple implicitly[MyCondition.Yes[T]]] fails, so I guess the type of transparent implicits isn't refined before implicit search resolution?

But maybe there's another way to define a conditional implicit as described above?

[soronpo]

Not completely sure what you are trying to do. Can you give an example of what you want to happen and what happens currently?

[adamw]

Sure, I'll try at least :)

I've got a macro which derives the Schema typeclass for any type T (it's implemented using Magnolia, but that's not really relevant I think).

Now I'd like to define another macro, which derives a Schema instance, but only for enums where all implementaitons are parameter-less. This isn't a condition I can express using type bounds - I need a compile-time check in a macro, if this derivation is at all applicable. If not, I want to continue the implicit search using the default mechanism - checking all the other available scopes.

My idea to constraint this special-case macro was to give it an implicit parameter, which would only be derived for parameter-less enums - which is demonstrated above using checkMyCondition. But I couldn't get it to work (using transparents etc.)