Scala 问题自定义控制结构<->类型参数

Question

我不明白如何在 Scala 中正确应用泛型类型。我已经设法实现了我自己的控制结构（“unless”、“ForEach”），但它们目前仅限于“Int”类型......有谁知道如何更改适用于泛型类型的实现？

实现对我来说并不重要，但我真的想保持现在的控制结构：

import Controls._ 

val Cond = false
val Elements = List(1,2,3)

Unless(Cond) {
  var sum = 0
  ForEach {
    sum += Element 
  } In(Elements) 
  println("The Sum: " + sum)
}

我尝试了几个小时，但我不知道类型参数问题的解决方案。这是我的“Int”有限实现：

object Controls {

  def Unless(cond: => Boolean)(block: => Unit) = {
    if(!cond) block
  }

  var current = 0
  def ForEach(block: => Unit) = {
    new {
      def In(list:List[Int]) = {
        list foreach { i =>
          current = i
          block
        }
      }
    }
  }

  def Element = current

}

非常欢迎任何提示，因为我现在真的陷入困境......

Answer 1

基本上，您希望在 Unless 块参数内注入定义：

Unless
(Cond)
{ // you want Element available here
  var sum = 0
  ForEach {
    sum += Element 
  } In(Elements) 
  println("The Sum: " + sum)
}

您不能在外部定义它，因为它会提前修复类型。所以我给你两个解决方案。首先，将某些内容注入到块中的传统方法是将其作为参数传递：

Unless(Cond) {
  var sum = 0
  ForEach { Element =>
    sum += Element 
  } In(Elements) 
  println("The Sum: " + sum)
}

您将无法获得单独运行的代码，因为编译器无法推断 元素。因此，这两个更改中的任何一个都是需要的：

  ForEach[int] { Element =>
  ForEach { Element: Int =>

代码如下所示：

object Controls {
  def Unless(cond: => Boolean)(block: => Unit) = {
    if(!cond) block
  }

  def ForEach[T](block: T => Unit) = {
    new {
      def In(list:List[T]) = {
        list foreach block
      }
    }
  }
}

另一个解决方案是创建一个特定于类型的控件的工厂，如下所示：

object Controls {
  def apply[T] = new Controls[T]

  class Controls[T] {
    def Unless(cond: => Boolean)(block: => Unit) = {
      if(!cond) block
    }

    private var current: T = _
    def Element = current
    def ForEach(block: => Unit) = {
      new {
        def In(list:List[T]) = {
          list foreach { i =>
            current = i
            block
          }
        }
      }
    }
  }
}

然后像这样使用它：

val controls = Controls[Int]; import controls._

其余的工作方式与你的例子。

Answer 2

def ForEach[T](block: => Unit): T = {
    var current: T = _
    new {
        def In(list: List[T]) = {
            list foreach { i =>
                current = i
                block
            }
        }
    }
    current
}

应该做到这一点。

编辑：当您在 ForEach 方法之后使用 current 时，您可能需要更改 ForEach 以返回 current。我编辑了代码片段来反映这一点。