通用特征的隐式转换

Question

我正在实现一个数据结构，并希望用户能够使用任何类型作为密钥，只要他提供一个合适的密钥类型来包装它。我有这个关键类型的特征。这个想法是进行从基类型到键类型的隐式转换，反之亦然（实际上）仅使用基类型。该特征如下所示：

trait Key[T] extends Ordered[Key[T]] {
  def toBase : T

  // Further stuff needed for datastructure...
}
object Key {
  implicit def key2base[T](k : Key[T]) : T = k.toBase
}

调用站点代码可能如下所示：

def foo[K <% Key[K]]( bar : Seq[K] ) = bar.sorted(0)

计划是 K 类型的值应隐式转换为已排序的 Key[K] 或排序on Key[K] 应该分别隐式使用，因此一切都应该正常。当然，没有办法在特征本身中实现隐式base2key。或者是否存在，可能使用隐式传递的类清单？考虑到这一点，我找不到任何参考资料。

是否可以以某种方式静态断言任何扩展 Key[T] 的类型都将带有隐式转换 T =>键[T]？遗憾的是，伴生对象不能有抽象方法。

假设这可行，整个企业是否可行，或者所述用例是否需要多个链式隐式转换？ （正如我所读到的，链接不会发生。）

附录：通过上面的定义，我可以对 Node(key : K, ...) 的序列进行排序（在K <% Key[K])，使用 sortWith(_.key <= _.key)，但不使用 sortBy(_.key)。因此，显然，从 K 到 Key[K] 的转换是隐式发生的，即使我从未在任何地方声明过它，但没有 OrderingKey[K] 上的 code> 隐式可用。这是怎么回事？

Answer 1

你问“是否有可能以某种方式静态断言任何扩展 Key[T] 的类型都将带有隐式转换 T => Key[T]？遗憾的是，不能有抽象方法。”

但您的示例是静态断言：当您需要从 T 到 Key[T] 的视图时，您在编译时断言只能调用 foo< /code> 用于可以提升为键的类型。或者我误解了什么？

关于附录：您说您对“从 K 到 Key[K] 的转换隐式发生感到惊讶，即使我从未在任何地方声明过它”。事情是，你确实声明了它： T <% Key[T] （我在这里使用 T 而不是 K，你似乎在这里混淆了基本 *T*ype 和 *K*ey 的概念吗？）。这与因此相同

def foo[T](bar : Seq[T])(implicit view: T => Key[T]) = bar.sortWith(_ <= _)(0)

，当您执行 sortWith(_ <= _) 时，您将 T 强制转换为 Key[T] （对于其中 < code><= 根据特征 Ordered[Key[T]] 定义）。

以您的 Node 为例，为什么不希望

case class Node[K](key: K)
def test[K](bar: Seq[Node[K]])(implicit ord: Ordering[K]) = bar.sortBy(_.key)(0)

有所帮助......

Answer 2

这是您问题的可能解决方案（希望我正确理解您的要求）：

// Key stuff

trait Keyable[T] {
  def toKey(t: T): Key[T]
}

trait Key[T] extends Ordered[Key[T]] {
  def toBase() : T
}

object Key {
  implicit def key2base[T](k : Key[T]) : T = k.toBase
  implicit def base2key[T : Keyable](k : T) : Key[T] = implicitly[Keyable[T]].toKey(k)
}

// more concrete stuff - namely A

class A(val i: Int) {
  override def toString = "A {" + i + "}"
}

object A {
  implicit val aKeyable = new Keyable[A] {
    def toKey(t: A) = new Key[A] {
      def toBase() = t
      def compare(that: Key[A]) = t.i compare that.i
    }
  }
}

// testing

def foo[K : Keyable](bar: Seq[K]) = bar.sortBy(implicitly[Keyable[K]].toKey)

val list = List(new A(5), new A(1), new A(3))

println(foo(list)) // prints: List(A {1}, A {3}, A {5})

在这种情况下，Key[T] 是类型 T 和 Keyable[T] 的包装器 是类型调用，允许将类型 T 转换为 Key[T]。我还展示了 base2key 的样子。

Answer 3

在这个答案中，我会保留目前最好的版本以供参考。使用这个答案可以更加集中问题;根据 这个 < /a>.

Key 特征保持不变；我添加了一个特定的函数来进行说明：

trait Key[T] extends Ordered[Key[T]] {
  def toBase : T
  def foo(i : Int) : Key[T]
}
object Key {
  implicit def key2base[T](k : Key[T]) : T = k.toBase
  implicit def ordering[T <% Key[T]] = new Ordering[T]{
    def compare(x: T, y: T) = x compare y
  }
}

以下内容按预期工作（如果完成了 import Key._）：

def min[K <% Key[K]](l : Seq[K]) : K = l.sorted.head

让我们假设我们有一个简单的 class Node[K](val key : K ）。同样，事情按预期进行：

def min[K <% Key[K]](l : Seq[Node[K]]) : Node[K] = l.sortBy(_.key).head

再举一个例子，假设此代码仅使用 Key[T] 接口：

def test[K <% Key[K]](bar : Seq[K]) = 
  bar.map(_.foo(3)).sorted

请注意，由于 map 生成 Seq[直接Key[K]]；排序不需要转换。现在，如果我们有 Key 的正确实现，那么

class StringKey(val key : String) extends Key[String] {
  def foo(i : Int) =  StringKey(this.key + "_" + i)
  def toBase = key
  override def compare(other : Key[String]) = -1*this.key.compare(other.toBase)
}
object StringKey {
  def apply(key : String) = new StringKey(key)
  def unapply(key : String) = Some(key)
  implicit def string2key(s : String) = StringKey(s)
}

下面的内容应该可以工作：

import StringKey.string2key
import Key.key2base
val bla : Seq[String] = test(Seq("b", "c", "a")).map(_.capitalize)
println(bla)
// expected output: Seq(C_3, B_3, A_3)

但实际上，没有找到从 StringKey 到 String 的转换：

error: value capitalize is not a member of this.Key[java.lang.String]

这很奇怪；如果使用泛型类型参数声明，则存在从 Key[String] 到 String 的转换。