Scala 高级类型用法

Question

背景

我正在使用 Scala 开发一个事件库。 In my library 你可以这样定义事件：

val e1 = new ImperativeEvent[Int]

你可以这样触发它们：

e1(42)

您可以像这样创建反应：

val r1 = (i: Int) => println(i)

并将它们附加到这样的事件中：

e1 += r1

还有一些其他的东西（比如事件转换、合成等）。我使用Esper CEP engine 作为我图书馆的后端。 Esper 对大多数操作使用一种称为 EPL 的类似 SQL 的语言。

问题

我正在尝试实现一些更高级的概念，例如事件连接。所以现在你可以像这样定义具有多个属性的事件（使用元组类型）：

val e2 = new ImperativeEvent[(Int, String)]

然后像这样加入他们：

val e3 = e1 join e2 windowLength (30) on "E1.P1 = E2.P1"

在它们各自的第一个属性相等的条件下，对最后 30 次出现的 e1 和 e2 执行连接。

这没关系，但我想在我的实现中去掉字符串以使事件表达式类型可检查。我想把连接表达式改成这样：

val e3 = e1 join e2 windowLength (30) on e1._1 === e2._1

类似于它在例如完成的方式。 Squeryl。这样做的问题是，我无法访问元组类型的元素的类型...

问题

如何静态访问元组类型？现在我只能通过反射在运行时访问它们，这对我没有帮助。我很确定元组无法实现我想要实现的目标，但我想知道使用 shapeless 库中的 HLists 或类似的东西是否有助于实现我的目标。

Answer 1

如果没有关于您的 DSL 的更多详细信息，恐怕不清楚您所说的“静态访问元组类型”是什么意思。这是一个简化的 API 版本，它对元组类型没有任何问题：

class Event[T] {
  def joinOn[T2, R](ev2: Event[T2])(f: (T, T2) => R) = new Event[R]
}

您可以按如下方式使用它：

val e1 = new Event[(Int, String)]
val e2 = new Event[(Int, String)]
val e3 = e1.joinOn(e2)(_._1 == _._2)

应该很容易看出如何将其扩展为支持您的 join/windowLength/on 语法。

更新： 我可以看到您的用例很复杂，因为您需要将 Scala 编码的查询表达式翻译成另一种查询语言。在这种情况下，您希望 on 方法的签名看起来像：

def on[T2, R](f: (Expr[T], Expr[T2]) => Expr[R]): Event[R]

在内部，每个事件对象都将创建自己的 Expr 表示，并将此表示传递给提供给 on 方法的函数。

Expr 类型可以这样定义：

trait Expr[T] {
  protected val repr: String

  def _1[A](implicit ev: T <:< Tuple2[A,_]): Expr[A] = 
    ??? // create an Expr[A] whose string representation is (repr + ".P1")

  // abstracting over tuple arities (using Shapeless)
  import shapeless._, nat._
  @scala.annotation.implicitNotFound("A tuple with at least 3 elements is required")
  type At2 = ops.tuple.At[T, _2]

  def _3(implicit at: At2): Expr[at.Out] = 
    ??? // create an Expr[at.Out] whose string representation is (repr + ".P3")

  def ===(other: Expr[T]): Expr[Boolean] =
    ??? // create an Expr[T] whose string representation is (repr + " = " + other.repr)
}

这显然大大简化了，但应该有助于您入门。

Answer 2

我。有一个SynapseGrid 函数式反应式编程库。在资源中，您可以找到一些有用的提示。

库中的所有处理都是类型安全的。您可以完全访问元组。

例如，如果我必须在 SynapseGrid 中实现 join，我将定义一个方法 join，其签名如下：

implicit class RichContact[T] (c:Contact[T]){ // contact == event in SynapseGrid's terminology
  ...
  def join[T2](c2:Contact[T2]):Contact[(T, T2)] = {
    // construct a contact/event that do nothing more than joining two events.
  }
}

implicit class RichTupledContact[T, T2](c:Contact[(T, T2)])
  def windowLength(len:Int):Contact[(T, T2)] = { 
    // construct the next step of processing events — window 
  }
}

等等。逐步构建事件处理大大简化了系统的构建。

二。但是，如果您需要一次构造所有内容，那么您可能会返回一些具有构造方法的中间对象：

implicit class RichContact[T] (c:Contact[T]){ // contact == event in SynapseGrid's terminology
  ...
  def join[T2](c2:Contact[T2]):Contact[(T, T2)] = {
    new {
      def windowLength(len:Int) = ...
    }
  }
}