1

很难用几句话来解释问题，所以我准备了一些代码来提出问题。

让我们开发类型Container[T1,T2]和隐式容器，用于在该容器中包装任何值。如果该值是 Container[T1,T2]包装类型，则应返回相同的类型。更多的过度包装方法应该采用 T1 类型的参数（与容器中的相同），并产生具有替换 T1 值的容器。解决方案必须符合泛型和隐含方式。

听起来有点混乱，让我们阅读代码:)

  • 容器：

    case class Container[T1, T2](t1: T1, t2: T2)

  • 带有包装方法的特征：

      trait ToContainer[A] {
    def wrappingMethod[E](e: E): Container[E, A]
  }

  • 隐含对象：

      object ToContainers {
    import language.implicitConversions

    implicit def implicitMethod[A](a: => A) = new ToContainer[A] {
      def wrappingMethod[E](e: E): Container[E, A] = Container(e, a)
    }

    implicit def implicitMethod2[E, A] (c: => Container[E, A])(implicit d:DummyImplicit): ToContainer[A] = new ToContainer[A] {
      def wrappingMethod[EX](e: EX): Container[EX, A] = c.copy(e)
    }
  }

这就是代码。

问题是我需要以某种方式将EX函数的类型参数绑定def wrappingMethod[EX]到.Edef implicitMethod2[E, A]

在此之后，这样的事情应该可以工作（并且可以工作）：

        scala>  import     ToContainers._
        import ToContainers._

        scala>  val c1: Container[String, Int] = 1234.wrappingMethod("abc")
        c1: Container[String,Int] = Container(abc,1234)

        scala>  val c2: Container[String, Int] = c1.wrappingMethod("XXX")
        c2: Container[String,Int] = Container(XXX,1234)

...但这必须产生编译错误，并且不要:(（看看类型：c1 有 [String, Int] 和 c3 有 [Int,Int]。我想防止这种情况发生。）

        scala>  val c3 = c1.wrappingMethod(0)
        c3: Container[Int,Int] = Container(0,1234)

任何想法都非常感谢:)

顺便说一句：我正在使用这个版本的 scala：

欢迎使用 Scala 版本 2.10.0-M7（Java HotSpot(TM) 64 位服务器 VM，Java 1.7.0_07）

编辑：

我已经修复了错误。代码现在正在运行。

4

2 回答 2

2

您提供的示例代码不起作用，因此提供一个好的答案有点困难。但是，您不能只执行以下操作：

implicit def implicitMethod2[E, A] (c: => Container[E, A])(implicit d:DummyImplicit): ToContainer[A] = new ToContainer[A] {
  def wrappingMethod[E](e: E): Container[EX, A] = c.copy(e)
}

所以只需将EX类型参数替换为E.

于 2012-10-17T17:17:03.977 回答
0

您需要将类型参数移动E到ToContainer：

trait ToContainer[E, A]

  def wrappingMethod(e: E): Container[E, A]

}

object ToContainers {
  import language.implicitConversions

  implicit def implicitMethod[E, A](a: => A) = new ToContainer[E, A] {

    def wrappingMethod(e: E): Container[E, A] = Container(e, a)

  }

  implicit def implicitMethod2[E, A] (c: => Container[E, A])(implicit d:DummyImplicit): ToContainer[E, A] = new ToContainer[E, A] {

    def wrappingMethod(e: E): Container[E, A] = c.copy(e)

  }

}
于 2012-10-24T09:56:26.770 回答