4

我正在使用 Scala 类型安全构建器模式来处理简单的休息请求。这作为一个流利的 api 非常有用。

sealed abstract class Method(name: String)

case object GET extends Method("GET")
case object POST extends Method("POST")

abstract class TRUE
abstract class FALSE

case class Builder[HasMethod, HasUri](
  method: Option[Method],
  uri: Option[String]) {

  def withMethod(method: Method): Builder[TRUE, HasUri] = copy(method = Some(method))
  def withUri(uri: String): Builder[HasMethod, TRUE] = copy(uri = Some(uri))
}

implicit val init: Builder[FALSE, FALSE] = Builder[FALSE, FALSE](None, None)

//Fluent examples
val b1: Builder[TRUE, FALSE] = init.withMethod(GET)
val b2: Builder[TRUE, TRUE] = init.withMethod(GET).withUri("bar")

我想通过允许将Method实例转换为Builder实例来使其更像 DSL，但是当我添加尝试隐式包含init构建器时，隐式转换和类型参数的组合会使编译器感到困惑。

implicit def toMethod[HasUri](m: Method)
  (implicit builder: Builder[_, HasUri]): Builder[TRUE, HasUri] = builder.withMethod(m)

// ** ERROR **: could not find implicit value for parameter builder: 
//              Builder[_, HasUri]  
val b3: Builder[TRUE, TRUE] = GET withUri "foo"

// However the implicit parameter is discovered fine when function is called directly
val b4: Builder[TRUE, FALSE] = toMethod(GET)
val b5: Builder[TRUE, TRUE] = toMethod(GET) withUri "foo"

除 b3 外，所有行都编译。当toMethod函数被显式调用时，可以隐式找到 builder 参数。此外，如果我删除通用参数（和类型安全），代码将按预期工作。

这是 scala 隐式转换的限制吗？还是我错过了实现这一目标的正确语法？

我想隐式地发现初始构建器实例，以使用户能够为他们自己的初始构建器提供一些构建器字段的默认值。

更新

我留下了一些代码以使示例保持简单，因为它只是我要修复的隐式转换。

类型安全的构建器模式在这里得到了很好的概述：http: //blog.rafaelferreira.net/2008/07/type-safe-builder-pattern-in-scala.html

之后，您只能在具有方法和 uri时调用该build方法。Builder

我想发现builder作为隐式参数的原因是为了支持DSL中的以下情况。

url("http://api.service.org/person") apply { implicit b =>
  GET assert(Ok and ValidJson)
  GET / "john.doe" assert(NotFound)
  POST body johnDoeData assert(Ok)
  GET / "john.doe" assert(Ok and bodyIs(johnDoeData))
}

在这些情况下

  1. 使用指定的 uri 创建一个新的构建器url
  2. 然后在闭包中重用它implicit b =>
  3. 该assert方法仅可用，因为已指定 uri 和方法
  4. 附加到当前 uri，这/仅在构建器指定了 uri 时才可用。

指定方法和 uri 的另一个示例

GET url("http://api.service.org/secure/person") apply { implicit b =>
  auth basic("harry", "password") assert(Ok and ValidJson)
  auth basic("sally", "password") assert(PermissionDenied)
}
4

2 回答 2

1

我感觉您的隐式解析问题并非来自 Scala 类型系统中的任何限制，而是取决于您在此处指定的存在类型：

implicit def toMethod[HasUri](m: Method)
  (implicit builder: Builder[_, HasUri]): Builder[TRUE, HasUri] = builder.withMethod(m)

如果我没记错的话，在这种情况下，存在类型被视为 Nothing。Nothing 是每个可能的 Scala 类的子类，因此您的方法实际上变为：

implicit def toMethod[HasUri](m: Method)
  (implicit builder: Builder[Nothing, HasUri]): Builder[TRUE, HasUri] = builder.withMethod(m)

然后，Scala 将在当前范围内查找 Builder[Nothing,HasUri] 的子类以提供给您的方法，并且除了 Builder[Nothing,HasUri] 之外没有可以匹配所需类型的类，因为您的构建器类是不变的，即Builder[A,B]<:<Builder[C,D]当夫A=:=C & B=:=D

因此，您有两种选择：

  • 给签名加一个参数，toMethod[HasUri]变成toMethod[A,HasUri]
  • 利用Scala正确实现类型差异

由于您要强制您的 Builder[A,HasUri] 是 Builder[Nothing,HasUri] 的子类，并且

Nothing <:< A for any A

你想强制Builder[A,HasUri] <:< Builder[B,HasUri]当 iff B<:<Aie Builder 在它的第一个类型参数中是逆变的。您可以通过在类型前面放置一个 - 符号来强制控制：

Builder[-HasMethod, HasUri]在 HasMethod 中是协变的，在 HasUri 中是不变的

结论

类型系统很强大，但即使是简单的任务也不一定要使用复杂的模式：

  • HasUri 不是从 m 推断出来的，因为它是方法 toMethod 的类型参数
  • 没有推断 HasMethod，因为您使用 _ 擦除它

如果参数不包含在您的解析中，那么使用带有两个泛型参数的隐式参数有什么意义？我只想写：

case class DefaultBuilder(m:Method) extends Builder[True,HasUri]

当你最终遇到这种情况时，正如有人已经说过的那样，那是因为你的设计对于问题来说是错误的。你能解释为什么构建器必须隐含在 toMethod 中吗？

implicit def toMethod(m:Method) = DefaultBuilder(m)
于 2013-05-17T15:13:28.747 回答
1

这段代码现在在 Scala 2.11 中按原样工作，但在 Scala 2.10（我用来编写此原始代码）中不起作用。

我一直在寻找可能是这种情况的原因，并且只能在 scala-lang 的 jira 中找到这个错误。

https://issues.scala-lang.org/browse/SI-3346

我在 Scala 2.10 中尝试了多种方法来解决这个问题，但都做不到。这些包括@Edmondo1984 的建议和限制HasMethod和HasUri参数如下：

case object GET extends Method("GET")
case object POST extends Method("POST")

sealed trait TBool
trait TTrue extends TBool
trait TFalse extends TBool

case class Builder[HasMethod <: TBool, HasUri <: TBool](method: Option[Method],
                                                        uri: Option[String]) {

  def withMethod(method: Method): Builder[TTrue, HasUri] = copy(method = Some(method))
  def withUri(uri: String): Builder[HasMethod, TTrue] = copy(uri = Some(uri))
}

object Builder {
  implicit val init: Builder[TFalse, TFalse] = Builder[TFalse, TFalse](None, None)

  // Example build method
  implicit class CanExecute(builder: Builder[TTrue, TTrue]) {
    def execute(): String = s"Build(${builder.method} ${builder.uri}"
  }
}


//Fluent examples
val b1: Builder[TTrue, TFalse] = init.withMethod(GET)
val b2: Builder[TTrue, TTrue] = init.withMethod(GET).withUri("bar")


implicit def toMethod[HasUri <: TBool](m: Method)
                                      (implicit builder: Builder[_, HasUri]): Builder[TTrue, HasUri] = builder.withMethod(m)

// ** ERROR **: could not find implicit value for parameter builder:
//              Builder[_, HasUri]
// ** BUT ** Works in Scala 2.11
val b3: Builder[TTrue, TTrue] = GET withUri "foo"

GET withUri "foo" execute ()
于 2016-03-14T21:51:01.053 回答