对象的 Scala 隐式转换

Question

假设我有以下代码片段：

import scala.language.implicitConversions
sealed trait Command {
val typeName: String
}
object Command {
implicit def command2String(implicit c: Command): String =
c.typeName
}
case object SendMessageCommand extends Command {
override val typeName: String = "send_message"
}

我想将String与没有明确转换Command后代进行比较。例如：

"sendMessage" == SendMessageCommand

Q1： 在 Scala 中可以吗？

Q2：我是否可以定义泛型隐式转换，将已知类型(如 String(转换为超类类型(如我的情况中的Command(？

例如：

implicit def string2Command(implicit s: String): Command = {
case "send_message" => SendMessageCommand
case _ => // some error thrown
}

附言我知道这不是惯用的 Scala，但找到正确的方法会很棒。

Answer 1

是的，这是可能的，但不能使用==，因为 Scala 仅支持这些情况的隐式转换：转换为预期类型、选择接收器的转换以及隐式参数，因此隐式不适用于比较情况。相反，您必须在Command trait中创建comparison method，如下所示。

sealed trait Command {
val typeName: String
def isEqual(c: Command) = c.typeName == this.typeName
}
object SendMessageCommand extends Command {
override val typeName: String = "send_message"
}
implicit def stringToCommand(s: String) = new Command {override val typeName: String = s}
implicit def commandToString(c: Command) = c.typeName
val strToCmdCompare = "send_message" isEqual SendMessageCommand
val cmdToStrCompare = SendMessageCommand isEqual "send_message"
println(strToCmdCompare)    //print true
println(cmdToStrCompare)    //print true

现在，回到你的第二个问题，是的，可以定义一个通用隐式转换，将任何给定类型转换为另一个类型实例。但是，由于我了解您的情况，您有命令对象的列表，并且您希望给定字符串名称的这些对象中的特定命令。为此，您必须拥有这些实例列表。

sealed trait Command {
val typeName: String
//This is required for implicit conversion.
override def toString: String = typeName
}
object SendMessageCommand extends Command {
override val typeName: String = "send_message"
}
object AddMessageCommand extends Command {
override val typeName: String = "add_message"
}
object UpdateMessageCommand extends Command {
override val typeName: String = "update_message"
}
object DeleteMessageCommand extends Command {
override val typeName: String = "delete_message"
}
//List of commands.
implicit val cmds: List[Command] = List(SendMessageCommand, AddMessageCommand, UpdateMessageCommand, DeleteMessageCommand)
//Convert given type T into type U.
implicit def convert[T, U](s: T)(implicit list: List[U]): Option[U] = {
list.find(_.toString == s.toString)
}
val res: Option[Command] = "add_message"
println((res.getOrElse(null) == AddMessageCommand)) //print true

注意：由于我正在通过将转换中的两个类型实例转换为string来比较它们，因此对于此用例，我必须覆盖命令中的toString方法。如果类型T不是字符串，则可能也需要这样做。此外，您可以根据需要在convert method中实现自己的逻辑，而不是与toString转换进行比较。

Answer 2

你不能用==来做到这一点，但你可以定义你自己的运算符：

case class Foo(s: String) {
def eq(x: Any) = x match {
case Foo(str) => str == s
case str: String => str == s
cae _ => false
} 
def ==: (x: Any) = eq(s)
def :== (x: Any) = eq(s)
}
"bar" ==: Foo("bar") // true
Foo("bar") :== "bar" // true 
Foo("bar") ==: Foo("bar") // true 

这是有效的，因为scala中的一个特殊技巧，使方法，其名称以冒号结尾绑定到右侧而不是左侧："bar" ==: Foo("bar")表示Foo("bar").:==("bar")，而不是"bar".:==Foo("bar")

至于第二个问题，我不确定我是否理解你在问什么......"我可以定义隐式转换吗？"嗯，是的，你可以:)