1

我想定义一个方法，它的返回类型取决于传递给该方法的参数类型和封闭特征的类型参数。很难用语言来描述我的意思，所以下面是一些片段来解释。

我有一些积木

// This is the target of a binding
trait BindableValue[T] {
  def set(value: T): Unit

  // this is the method I am strugling with
  def bindTo[S](o: S) = ???
}

// This will dispatch events of type T
trait Observable[T]

// This represents a value of type T that will 
// dispatch events if the value changes
trait ObservableValue[T] extends Observable[T] {
  def value: T
}

// An Observable can be converted to an optional ObservableValue
object ObservableValue {
  implicit def wrap[T](o:Observable[T]):ObservableValue[Option[T]] = 
    new ObservableValue[Option[T]] {
      val value = None
    }
}

绑定具有源和目标，并存在两种：

  1. Complete：源类型参数和目标类型参数相同
  2. 不完整：源和目标类型参数不同

...

trait Binding[S, T] {
  def source: ObservableValue[S]
  def target: BindableValue[T]
}

class CompleteBinding[T](
  val source: ObservableValue[T], 
  val target: BindableValue[T]) extends Binding[T, T]

class IncompleteBinding[S, T](
  val source: ObservableValue[S], 
  val target: BindableValue[T]) extends Binding[S, T]

我可以构造以下实例。

val bindable1 = new BindableValue[Int] { def set(value:Int) = {} }
val property1 = new ObservableValue[Int] { def value = 0 }
val property2 = new ObservableValue[String] { def value = "" }

val bindable2 = new BindableValue[Option[Int]] { def set(value:Option[Int]) = {} }
val event1 = new Observable[Int] {}
val event2 = new Observable[String] {}

现在我想像这样使用这些实例：

// 'a' should be of type CompleteBinding
val a = bindable1 bindTo property1

// 'b' should be of type IncompleteBinding
val b = bindable1 bindTo property2

// 'c' should be of type CompleteBinding
val c = bindable2 bindTo event1

// 'd' should be of type IncompleteBinding
val d = bindable2 bindTo event2

我不知道如何定义该方法bindTo，以便它编译上述 4 行并为所有值提供正确的具体类型。我只是想念有关 Scala 类型系统的知识。

尽管我很想找到一个解决方案，但我也想了解自己将来如何找到这样的解决方案。如果您对上述问题有解决方案，您能否向我指出一些可以用来教育自己的资源？

4

1 回答 1

3

类型类可以帮助您解决问题。首先让我们定义简单的特征：

trait Composeable[A, B, R] {
    def compose(a: A, b: B): R
}

它只是将它们组合a到b其他类型的容器中R。

CompleteBinding现在让我们为伴生对象和在伴生对象中定义它的 2 个具体实现，IncompleteBinding并使它们隐含：

object Composeable extends LowPriorityComposables {
    implicit def  comCommplete[T] = new Composeable[ObservableValue[T], BindableValue[T], CompleteBinding[T]] {
        def compose(a: ObservableValue[T], b: BindableValue[T]) = new CompleteBinding(a, b)
    }
}

trait LowPriorityComposables {
    implicit def  comIncommplete[S, T] = new Composeable[ObservableValue[S], BindableValue[T], IncompleteBinding[S, T]] {
        def compose(a: ObservableValue[S], b: BindableValue[T]) = new IncompleteBinding(a, b)
    }
}

如您所见，实现非常简单。它只需要ObservableValue和BindableValue然后结合在Binding. 我将它们分成不同的特征，因为通常它们都可以使用，如果您观察并绑定某种类型的相同值T（的情况CompleteBinding）。通过提取comIncommplete单独的特征，我告诉编译器，如果没有找到其他合适的隐式，它应该使用它。换句话说，您告诉编译器始终尝试应用CompleteBinding，如果无法完成，则IncompleteBinding应该应用。

唯一剩下的就是定义bindTo使用Composeable类型类的方法：

def bindTo[S, R](o: ObservableValue[S])(implicit ev: Composeable[ObservableValue[S], BindableValue[T], R]): R = 
    ev.compose(o, this)

在这里我说，第一个参数是包含 type 值的o一些参数，但我也想编译以找到一个证据，即存在一些隐含的，证明我可以用. 当我有这样的证据时，我只是用这个（可绑定的）组成可观察的。如您所见，类型参数类似于自由变量 - 编译器可以自行计算，因此您始终可以从方法返回创建类型信息。ObservableValueSObservableValue[S]BindableValue[T]RbindTo

现在你所有的测试用例都应该编译得很好：

val a: CompleteBinding[Int] = bindable1 bindTo property1
val b: IncompleteBinding[String, Int] = bindable1 bindTo property2
val c: CompleteBinding[Option[Int]] = bindable2 bindTo event1
val d: IncompleteBinding[Option[String], Option[Int]] = bindable2 bindTo event2
于 2013-02-03T16:29:25.567 回答