给定以下类别:
case class AddRequest(x: Int, y: Int)
case class AddResponse(sum: Int)
case class ToUppercaseRequest(str: String)
case class ToUppercaseResponse(upper: String)
如何以类型安全的方式定义某些功能:
def process(req: ???): ???
这样,以下条件成立:
val r1: AddResponse = process(AddRequest(2, 3))
val r2: ToUppercaseResponse = process(ToUppercaseRequest("aaa"))
另外,以下内容不应编译:
val r3 = process("somestring")
最佳答案
在Scala中,这完全有可能而且是完全合理的。例如,这种东西到处都是Shapeless,并且类似的东西(但原理性较差)是在Spray等中显示的磁铁图案的基础。
更新:请注意,以下解决方案假定“给定以下类”意味着您不想自己接触案例类。如果您不在乎,请参阅下面答案的第二部分。
您需要一个将输入类型映射到输出类型的类型类:
case class AddRequest(x: Int, y: Int)
case class AddResponse(sum: Int)
case class ToUppercaseRequest(str: String)
case class ToUppercaseResponse(upper: String)
trait Processable[In] {
type Out
def apply(in: In): Out
}
然后是一些类型类实例:
object Processable {
type Aux[I, O] = Processable[I] { type Out = O }
implicit val toUppercase: Aux[ToUppercaseRequest, ToUppercaseResponse] =
new Processable[ToUppercaseRequest] {
type Out = ToUppercaseResponse
def apply(in: ToUppercaseRequest): ToUppercaseResponse =
ToUppercaseResponse(in.str.toUpperCase)
}
implicit val add: Aux[AddRequest, AddResponse] =
new Processable[AddRequest] {
type Out = AddResponse
def apply(in: AddRequest): AddResponse = AddResponse(in.x + in.y)
}
}
现在,您可以使用此类型类定义
process
:def process[I](in: I)(implicit p: Processable[I]): p.Out = p(in)
哪个可以按需工作(请注意适当的静态类型):
scala> val res: ToUppercaseResponse = process(ToUppercaseRequest("foo"))
res: ToUppercaseResponse = ToUppercaseResponse(FOO)
scala> val res: AddResponse = process(AddRequest(0, 1))
res: AddResponse = AddResponse(1)
但是它不适用于任意类型:
scala> process("whatever")
<console>:14: error: could not find implicit value for parameter p: Processable[String]
process("whatever")
^
您甚至不必使用依赖于路径的类型(您应该只可以在类型类上具有两个类型参数),但是如果process您必须显式提供type参数。
更新:上面的所有操作均假定您不想更改案例类签名(绝对没有必要)。但是,如果您愿意更改它们,则可以更简洁一些:
trait Input[Out] {
def computed: Out
}
case class AddRequest(x: Int, y: Int) extends Input[AddResponse] {
def computed: AddResponse = AddResponse(x + y)
}
case class AddResponse(sum: Int)
case class ToUppercaseRequest(str: String) extends Input[ToUppercaseResponse] {
def computed: ToUppercaseResponse = ToUppercaseResponse(str.toUpperCase)
}
case class ToUppercaseResponse(upper: String)
def process[O](in: Input[O]): O = in.computed
然后:
scala> process(AddRequest(0, 1))
res9: AddResponse = AddResponse(1)
scala> process(ToUppercaseRequest("foo"))
res10: ToUppercaseResponse = ToUppercaseResponse(FOO)
您应该首选哪种多态性(参数或临时)完全取决于您。如果希望能够描述任意类型之间的映射,请使用类型类。如果您不在乎或主动不希望此操作可用于子类型,请使用子类型化。
关于scala - 如何定义其输出类型取决于输入类型的函数,我们在Stack Overflow上找到一个类似的问题:https://stackoverflow.com/questions/36310264/