Modifier trait should not qualify as a SAM type about scala-dom-types HOT 5 CLOSED

How about using a typeclass for the implicit conversion of A => Modifier[A] to Modifier[A]? So you could have a typeclass AsModifier[F] with instances for [A] Modifier[A] and [A] A => Modifier[A]. Instead of accepting a Modifier and implicitly converting a function to Modifier, your method would then expect something that can be an AsModifier. This should not trigger a SAM conversion.

def func[T : AsModifier](modifier: T) = ???

from scala-dom-types.

Hm thanks, looks like a legit solution for this SAM problem in general. However, in this particular case I don't think it's a good fit because of probable performance impact on both compilation time (implicit search for every modifier, not just for thisNode => modifier) and runtime (I don't think Scala.js will be able to optimize away the typeclass layer, so probably extra allocated objects and extra function calls). This matters because in a frontend app method calls which accept Modifier/AsModifier params would be extremely plentiful.

I also asked this on SO btw.

from scala-dom-types.

I also tried

  trait MetaModifier[-El] extends AsModifier[El] {

    override def apply(el: El): Unit = {
      makeModifier(el)(el)
    }

    def makeModifier(el: El): Modifier[El]
  }

hoping the SAM conversion magic for a El => Modifier[El] literal will choose this trait instead of coercing Modifier[El] to Unit and magicking the whole literal into a Modifier[El], but no such luck, sigh.

from scala-dom-types.

However, in this particular case I don't think it's a good fit because of probable performance impact

Performance might be an issue, but maybe not even that bad (would need to try it out and see the generated code). I just find typeclasses more reliable and clear than implicit conversion functions :)

Interestingly, when requiring a trait mixin like (Modifier with AnyRef), the SAM conversion does not apply. Not sure, whether this is viable solution:

scala> trait F { def f(a:Int):String }
defined trait F
scala> def f(x:F with AnyRef) = x.f(1)
f: (x: F)String
scala> f((i:Int) => "a")
<console>:13: error: type mismatch;
 found   : Int => String
 required: F
       f((i:Int) => "a")

from scala-dom-types.

Thanks, that's a workable solution too.

I didn't want to compromise the simplicity of Modifier type signatures even a bit, and eventually I realized that I can just make the apply method non-abstract:

trait Modifier[-El] {
  def apply(el: El): Unit = ()
}

Admittedly, now you can potentially forget to provide an implementation for your Modifier subclass. But since end users by and large will not be creating modifiers on the fly, this seems like the best tradeoff to make, and a reasonable price to pay to completely disable undesired SAM sugar.

from scala-dom-types.