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
}

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

Answer 1

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

  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，因此我必须在Command中覆盖此用例的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")

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

Scala隐式转换为对象

2 个答案: