Question

我想用隐式格式化程序定义一个类型安全的相等匹配器：

trait Formatter[T] {
  def format(t : T) : String
}

implicit val StringFormatter : Formatter[String] = new Formatter[String] { def format(s: String) = s"'$s'" }
implicit def AnyFormatter[T] : Formatter[T] = new Formatter[T] { def format(t : T) = t.toString }

class MatcherOps[T : Formatter]( t : T) {
  def must_==(other : T) {
    if( t != other ) println( implicitly[Formatter[T]].format(other) ) else println("OK")
  }
} 

implicit def ToMatcherOps[T : Formatter](t : T) = new MatcherOps[T](t)

以下按预期方式工作：

"ha" must_== "ho"

将其编译（scalac -Xprint:typer）到

$anon.this.ToMatcherOps[String]("ha")($anon.this.StringFormatter).must_==("ho");

但是我希望这不会编译：

List(1,2) must_== Set(1,2)

而是将（scalac -Xprint:typer）编译为

$anon.this.ToMatcherOps[Object]($anon.this.ToMatcherOps[List[Int]](immutable.this.List.apply[Int](1, 2))($anon.this.AnyFormatter[List[Int]]))($anon.this.AnyFormatter[Object]).must_==(scala.this.Predef.Set.apply[Int](1, 2))

如您所见，ToMatcherOps被调用两次！

如果我将隐式格式化程序排除在外：

implicit def ToMatcherOps[T](t : T) = new MatcherOps[T](t)

然后编译按预期失败：

error: type mismatch;
  found   : scala.collection.immutable.Set[Int]
  required: List[Int]
List(1,2) must_== Set(1,2)
                     ^

但当然ToMatcherOps无法提供明智的Formatter（scalac -Xprint:typer）：

implicit private def ToMatcherOps[T >: Nothing <: Any](t: T): this.MatcherOps[T] = new this.MatcherOps[T](t)($anon.this.AnyFormatter[T]);

任何想法如何解决这个问题？感谢

Answer 1

这就是我想出来的。将隐式格式化程序参数从MatherOps类移动到它的方法。

package testpkg

trait Formatter[T] {
  def format(x: T): String
}

class MatcherOps[T](x : T) {
  def must_==(y: T)(implicit z: Formatter[T]) {
    if(x != y)
      println(z.format(y))
    else
      println("OK")
  }
}

object Test {
  implicit def ToMatcherOps[T](x: T) = new MatcherOps[T](x)

  implicit val StringFormatter = new Formatter[String] {
    def format(x: String) = "StringFormatter"
  }

  implicit val ListOfIntFormatter = new Formatter[List[Int]] {
    def format(x: List[Int]) = "ListOfIntFormatter"
  }

  implicit def AnyFormatter[T] = new Formatter[T] {
    def format(x: T) = "AnyFormatter"
  }

  def main(args: Array[String]): Unit = {
    List(1,2) must_== List(1,2,3) // ListOfIntFormatter
    "string" must_== "another string" // StringFormatter
    1 must_== 2 // AnyFormatter
    1 must_== false // type mismatch
  }
}

使用隐式参数进行隐式转换过于急切

1 个答案: