Scala 函数式编程体操

Question

我试图用尽可能少的代码和尽可能多的功能来执行以下操作：

def restrict(floor : Option[Double], cap : Option[Double], amt : Double) : Double

显然以下工作有效：

= (floor -> cap) match {
    case (None, None)       => amt
    case (Some(f), None)    => f max amt 
    case (None, Some(c))     => c min amt
    case (Some(f), Some(c)) => (f max amt) min c
  }

我真的希望有一些更优雅的东西，并且会接受使用 Scalaz 库！ 您可以假设以下内容为真：

floor.forall( f => cap.forall( _ > f))

---

如果有人感兴趣，这里有一些测试代码：

object Comparisons {
  sealed trait Cf {
    def restrict(floor: Option[Double], cap: Option[Double], amt: Double): Double
  }

  def main(args: Array[String]) {
    val cf : Cf = //TODO - your impl here!
    def runtest(floor: Option[Double], cap: Option[Double], amt: Double, exp : Double) : Unit = {
      val ans = cf.restrict(floor, cap, amt)
      println("floor=%s, cap=%s, amt=%s === %s (%s) : %s".format(floor, cap, amt, ans, exp, if (ans == exp) "PASSED" else "FAILED"))
    }
    runtest(Some(3), Some(5), 2, 3)
    runtest(Some(3), Some(5), 3, 3)
    runtest(Some(3), Some(5), 4, 4)
    runtest(Some(3), Some(5), 5, 5)
    runtest(Some(3), Some(5), 6, 5)

    runtest(Some(3), None, 2, 3)
    runtest(Some(3), None, 3, 3)
    runtest(Some(3), None, 4, 4)
    runtest(Some(3), None, 5, 5)
    runtest(Some(3), None, 6, 6)

    runtest(None, Some(5), 2, 2)
    runtest(None, Some(5), 3, 3)
    runtest(None, Some(5), 4, 4)
    runtest(None, Some(5), 5, 5)
    runtest(None, Some(5), 6, 5)

    runtest(None, None, 2, 2)
    runtest(None, None, 3, 3)
    runtest(None, None, 4, 4)
    runtest(None, None, 5, 5)
    runtest(None, None, 6, 6)
  }
}

Answer 1

编辑2：

在思考cataX方法时，我发现cataX只不过是一个简单的折叠。使用它，我们可以获得一个纯 scala 解决方案，无需任何额外的库。

所以，这就是：

( (amt /: floor)(_ max _) /: cap)(_ min _)

与 相同

cap.foldLeft( floor.foldLeft(amt)(_ max _) )(_ min _)

（并不是说这一定更容易理解）。

我想你不能有比这更短的时间了。

---

无论好坏，我们也可以使用 scalaz 来解决它：

floor.map(amt max).getOrElse(amt) |> (m => cap.map(m min).getOrElse(m))

甚至：

floor.cata(amt max, amt) |> (m => cap.cata(m min, m))

作为一名“普通”Scala 程序员，人们可能不知道所使用的特殊 Scalaz 运算符和方法（|> 和 >Option.cata）。它们的工作原理如下：

value |> function 转换为 function(value)，因此 amt |> (m => v fun m) 等于 v fun amt。

opt.cata(fun, v) 转换为

opt match {
  case Some(value) => fun(value) 
  case None => v
}

或opt.map(fun).getOrElse(v)。

请参阅 cata和 | >。

一个更对称的解决方案是：

amt |> (m => floor.cata(m max, m)) |> (m => cap.cata(m min, m))

---

编辑： 抱歉，现在变得很奇怪，但我也想有一个无积分版本。新的 cataX 已柯里化。第一个参数采用二元函数；第二个是一个值。

class CataOption[T](o: Option[T]) {
  def cataX(fun: ((T, T) => T))(v: T) = o.cata(m => fun(m, v), v)
}
implicit def option2CataOption[T](o: Option[T]) = new CataOption[T](o)

如果 o 匹配 Some，我们将返回具有 o 值的函数并应用第二个参数（如果 o 匹配） None 我们只返回第二个参数。

我们开始吧：

amt |> floor.cataX(_ max _) |> cap.cataX(_ min _)

也许他们已经在 Scalaz 中拥有了这个……？

Answer 2

不像 scalaz 版本那么简洁，但另一方面，没有依赖项，

List(floor.getOrElse(Double.NegativeInfinity), cap.getOrElse(Double.PositiveInfinity), amt).sorted.apply(1)

Answer 3

我将从这个开始：

def restrict(floor : Option[Double], cap : Option[Double], amt : Double) : Double = {
  val flooring = floor.map(f => (_: Double) max f).getOrElse(identity[Double] _)       
  val capping  = cap.map(f => (_: Double) min f).getOrElse(identity[Double] _)         
  (flooring andThen capping)(amt)                                                      
}                                                                                    

但我感觉我在这里错过了一些机会，所以我可能还没有完成。

Answer 4

这表明，如果将 cap 和 floor 转换为函数，组合会变得多么容易，而不是纯粹的简洁。

scala> val min = (scala.math.min _).curried                                        
min: (Int) => (Int) => Int = <function1>

scala> val max = (scala.math.max _).curried                                        
max: (Int) => (Int) => Int = <function1>

scala> def orIdentity[A](a: Option[A])(f: A => A => A): (A => A) = a ∘ f | identity
orIdentity: [A](a: Option[A])(f: (A) => (A) => A)(A) => A

scala> val cap = 5.some; val floor = 1.some                                        
cap: Option[Int] = Some(5)
floor: Option[Int] = Some(1)

scala> val ffloor = orIdentity(floor)(max)                                         
ffloor: (Int) => Int = <function1>

scala> val fcap = orIdentity(cap)(min)                                             
fcap: (Int) => Int = <function1>

scala> val capAndFloor = fcap ∘ ffloor                                             
capAndFloor: (Int) => Int = <function1>    

scala> (0 to 8).toSeq ∘ (capAndFloor)    
res0: Seq[Int] = Vector(1, 1, 2, 3, 4, 5, 5, 5, 5)

在 scalaz 中，我使用函子映射 MA#∘ 来作为使用 Option.map 和 Function1.andThen 的一种方式；和 OptionW#|，它是 Option.getOrElse 的别名。

更新

这就是我一直在寻找的：

scala> import scalaz._; import Scalaz._
import scalaz._
import Scalaz._

scala> val min = (scala.math.min _).curried                                        
min: (Int) => (Int) => Int = <function1>

scala> val max = (scala.math.max _).curried                                        
max: (Int) => (Int) => Int = <function1>

scala> def foldMapEndo[F[_]: Foldable, A](fa: F[A], f: A => A => A): Endo[A] = 
     |    fa.foldMap[Endo[A]](a => f(a))                                       
foldMapEndo: [F[_],A](fa: F[A],f: (A) => (A) => A)(implicit evidence$1: scalaz.Foldable[F])scalaz.Endo[A]

scala> val cap = 5.some; val floor = 1.some                                    
cap: Option[Int] = Some(5)
floor: Option[Int] = Some(1)    

scala> val capAndFloor = List(foldMapEndo(floor, max), foldMapEndo(cap, min)) ∑
capAndFloor: scalaz.Endo[Int] = scalaz.Endos$anon$1@4352d1fc

scala>(0 to 10).toSeq.map(capAndFloor)                                               
res0: Seq[Int] = Vector(1, 1, 2, 3, 4, 5, 5, 5, 5, 5, 5)

scalaz.Endo[A] 是 A => 的包装器。 A，双向都有隐式转换。有一个为 Endo[A] 定义的 Monoid 实例，Monoid#plus 链接函数，Monoid#zero code> 返回恒等函数。如果我们有一个 Endo[A] 的 List，我们可以对列表求和并得出单个值，该值可以用作 A =>一个。

MA#foldMap 将给定函数映射到 Foldable 数据类型，并使用 Monoid 简化为单个值。 foldMapEndo 在此之上提供了便利。这种抽象允许您轻松地将证明 Option 中的上限和下限更改为任何可折叠类型，例如 List。

val capAndFloor = Seq(foldMapEndo(List(1, 2, max), foldMapEndo(cap, min)).collapsee
capAndFloor: scalaz.Endo[Int] = scalaz.Endos$anon$1@76f40c39

另一次重构可能会导致：

val capAndFloor = Seq((cap, min), (floor, max)).foldMap { case (a, f) => foldMapEndo(a, f) }
capAndFloor: scalaz.Endo[Int] = scalaz.Endos$anon$1@25b85c8e

Answer 5

这个怎么样？

//WRONG
def restrict(floor : Option[Double], cap : Option[Double], amt : Double) : Double = 
   (floor.getOrElse(amt) max amt) min cap.getOrElse(amt)

[编辑]

第二次尝试：

def restrict(floor : Option[Double], cap : Option[Double], amt : Double) : Double = 
   floor.map(f => f max _).getOrElse(identity[Double] _)(
     cap.map(c => c min _).getOrElse(identity[Double] _)(amt))

对于我的口味来说，看起来有点太“lispy”，但通过了测试:-)

[第二次编辑]

第一个版本也可以“修复” :

def restrict(floor: Option[Double], cap: Option[Double], amt: Double): Double =
  (floor.getOrElse(-Double.MaxValue) max amt) min cap.getOrElse(Double.MaxValue)

Answer 6

没有更漂亮，没有更短，当然也没有更快！
但它更可组合，更通用，更“功能”：

编辑：使代码完全通用:)

def optWith[T](a: Option[T], b: T)(op:(T,T)=>T) =
  a map (op(b,_)) getOrElse b

def optMin[T:Numeric](a: Option[T]) =
  (b:T) => optWith(a, b)(implicitly[Numeric[T]].min)

def optMax[T:Numeric](a: Option[T]) =
  (b:T) => optWith(a, b)(implicitly[Numeric[T]].max)

def restrict[T,FT,CT](x:T, floor:Option[FT], ceil:Option[CT])
  (implicit ev:Numeric[T], fv:FT=>T, cv:CT=>T) =
  optMin(ceil map cv) compose optMax(floor map fv) apply(x)

更新2：还有这个版本，更好地利用数字

def optWith[T](a: Option[T])(op:(T,T)=>T) =
  (b:T) => a map (op(b,_)) getOrElse b

def restrict[T,FT,CT](x:T, floor:Option[FT], ceil:Option[CT])
  (implicit n:Numeric[T], fv:FT=>T, cv:CT=>T) =
  optWith(ceil map cv)(n.min) compose optWith(floor map fv)(n.max) apply(x)

我希望你喜欢类型签名:)

更新3：这里有一个与边界做同样的事情

def optWith[T, V <% T](op:(T,T)=>T)(a: Option[V]) =
  (b:T) => a map (op(b,_)) getOrElse b

def restrict[T:Numeric, FT <% T, CT <% T]
(floor:Option[FT], ceil:Option[CT], amt:T) = {
  val n = implicitly[Numeric[T]]; import n._
  optWith(min)(ceil) compose
  optWith(max)(floor) apply(amt)
}

如果没有别的......这很清楚地表明了原因导入参数将是一件好事。想象一下，如果以下是有效的代码：

def optWith[T, V <% T](op:(T,T)=>T)(a: Option[V]) =
  (b:T) => a map (op(b,_)) getOrElse b

def restrict[import T:Numeric,FT <% T,CT <% T]
(floor:Option[FT], ceil:Option[CT], amt:T) = {
  optWith(min)(ceil) compose
  optWith(max)(floor) apply(amt)
}

更新 4：将解决方案颠倒过来。这为未来的扩展提供了一些更有趣的可能性。

implicit def optRhs[T:Ordering](lhs:T) = new Object {
  val ord = implicitly[Ordering[T]]; import ord._

  private def opt(op: (T,T)=>T)(rhs:Option[T]) =
    rhs map (op(lhs,_)) getOrElse lhs

  def max = opt(ord.max) _
  def min = opt(ord.min) _
}

def restrict[T : Ordering](floor:Option[T], cap:Option[T], amt:T) =
  amt min cap max floor 

如果幸运的话，我将激励其他人利用我的解决方案构建更好的解决方案。这些事情通常都是这样进行的...

Answer 7

这在 Scalaz 中并不比在常规 Scala 中容易多少：（

def restrict(floor: Option[Double], cap: Option[Double], amt: Double) =
  floor.map(amt max).orElse(Some(amt)).map(x => cap.map(x min).getOrElse(x)).get

在 max 和 min 之后添加 _ 如果这让你感觉更好看的话 不过，一旦您了解了运算符

的作用，Scalaz 就更容易阅读了。

Answer 8

我发现当问题要求使用 Option 来指示可选参数时，通常有一种更自然的方式来表示缺少的参数。因此，我将在这里稍微更改一下接口，并使用默认参数来定义函数并使用命名参数来调用该函数。

def restrict(amt:Double,
            floor:Double = Double.NegativeInfinity,
            cap:Double=Double.PositiveInfinity):Double =
    (amt min cap) max floor

然后你可以调用：（

restrict(6)
restrict(6, floor = 7)
restrict(6, cap = 5)

相同原理的另一个示例。）

Answer 9

这是基于 Ken Bloom 的答案：

sealed trait Constrainer { def constrain(d : Double) : Double }

trait Cap extends Constrainer
trait Floor extends Constrainer
case object NoCap extends Cap { def constrain(d : Double) = d }
case object NoFloor extends Floor { def constrain(d : Double) = d }
implicit def d2cap(d : Double) = new Cap { def constrain(amt : Double) = d min amt }
implicit def d2floor(d : Double) = new Floor { def constrain(amt : Double) = d max amt }

def restrict(amt : Double, cap : Cap = NoCap, floor: Floor = NoFloor) : Double = {
  cap.constrain(floor.constrain(amt))
  //or (cap.constrain andThen floor.constrain) amt
}

最终会编写这样的代码：

restrict(amt, cap = 5D)
restrict(amt, floor = 0D)

我认为这非常棒，并且不会遇到 Ken 解决方案的问题（在我看来），即它是一个黑客！

Answer 10

这是修复 Landei 的第一个答案的另一种方法

def restrict(floor : Option[Double], cap : Option[Double], amt : Double) : Double = {
  val chopBottom = (floor.getOrElse(amt) max amt) 
  chopBottom min cap.getOrElse(chopBottom)
}

Answer 11

我添加了另一个答案，该答案的灵感来自于 retronym 和 Debilski - 基本上相当于将上限和下限转换为函数 (Double => Double< /code>，如果它们存在），然后通过它们组合折叠恒等函数：

def restrict(floor: Option[Double], cap: Option[Double], amt: Double) = {
  (identity[Double] _ /: List(floor.map(f => (_: Double) max f), cap.map(c => (_: Double) min c)).flatten){ _ andThen _ }(amt)
}

Answer 12

使用普通 Scala 和匿名 lambda 的简单解决方案，没有任何映射、折叠、Double.{Min/Max}Value 等：

def restrict(floor : Option[Double], cap : Option[Double], amt : Double) : Double =
  ((x:Double) => x min cap.getOrElse(x))(amt max floor.getOrElse(amt))

Answer 13

我最喜欢匹配大小写的初始解决方案 - 除此之外，我不明白 amt 意味着 amount （在德国，'amt' 意味着 'office '），我只知道 cap 是我戴在头上的东西......

现在这是一个非常平庸的解决方案，使用内部方法：

def restrict(floor : Option[Double], cap : Option[Double], amt : Double) : Double = {
  def restrict (floor: Double, cap: Double, amt: Double) =
    (floor max amt) min cap
  var f = floor.getOrElse (amt)            
  val c = cap.getOrElse (amt)   
  restrict (f, c, amt) 
}