Scala类包装部分应用的构造函数-如何使用它创建API方法？_Scala_Functional Programming_Closures_Implicits_Function Literal

Scala类包装部分应用的构造函数-如何使用它创建API方法？

scala functional-programming

Scala类包装部分应用的构造函数-如何使用它创建API方法？,scala,functional-programming,closures,implicits,function-literal,Scala,Functional Programming,Closures,Implicits,Function Literal,我正在尝试创建一个简单的api来处理小时间隔。（我知道乔达的时间，我并没有试图重新创造它。这只是一个练习）我想实现的是：（1）（2）我成功地实现了（1），如下所示：（忽略toString、Ordered trait、a.s.o）但是，我不知道如何实现（2）（即：Interval.formnutes）我似乎无法理解这一点在Time=>Interval上的这个“半间隔”包装有意义吗我根据经验设计了它，只是为了让from（..）.to（..）调用按计划工作，而不是考虑一些功能

我正在尝试创建一个简单的api来处理小时间隔。（我知道乔达的时间，我并没有试图重新创造它。这只是一个练习）

我想实现的是：

（1）

（2）

我成功地实现了（1），如下所示：（忽略toString、Ordered trait、a.s.o）

但是，我不知道如何实现（2）（即：Interval.formnutes）

我似乎无法理解这一点
在

Time=>Interval

上的这个“半间隔”包装有意义吗
我根据经验设计了它，只是为了让

from（..）.to（..）

调用按计划工作，而不是考虑一些功能概念模型
有没有更好的方法来实现这个api

谢谢

这就是我要做的：

object Interval {
   case class HalfInterval(start: Time) {
      def to(end: Time): Interval = Interval(start, end)
      def forMinutes(minutes: Int): Interval = to(getEnd(start, minutes))
      private def getEnd(start: Time, minutes: Int) = ??? 
    }
   def from(start: Time): HalfInterval = HalfInterval(start)
}

getEnd（）将minutes参数添加到start.minute，除以60，将结果添加到start.hours，其余部分添加到minutes，然后构建结束时间。（如果你第二天去的话，可能会按小时模数24计算）

编辑：HalfInterval应该是值类，但不要担心这一点。

这就是我要做的：

object Interval {
   case class HalfInterval(start: Time) {
      def to(end: Time): Interval = Interval(start, end)
      def forMinutes(minutes: Int): Interval = to(getEnd(start, minutes))
      private def getEnd(start: Time, minutes: Int) = ??? 
    }
   def from(start: Time): HalfInterval = HalfInterval(start)
}

编辑：半音程应该是值类，但别担心。

我同意卢西亚诺的观点，你的

半音程

有点不合时宜

但是，由于工程师喜欢开箱即用的东西，在你玩之前，你必须先把它组装起来，这里有另一个角度

你的

半间隔

说，给我一个

间隔

工厂，我会给你提供所需的

间隔

的证据

在这里，我将param类型更改为Any，但在本例中，它可以是

或[Int，Time]

，其中Int表示未来的分钟数，时间是结束时间。更一般地说，它可能是一种标记性状，比任何一种都更安全

要回答您的问题，开始时间来自哪里？您可以看到

from

中的闭包捕获了

start

import scala.language.implicitConversions
import util._

case class Time(hour: Int, minute: Int) {
  def +(delta: Int) = Time(hour, minute + delta) // TODO overflow minutes
}

case class Interval(start: Time, end: Time)

object Interval {
   case class HalfInterval(half: Any => Interval) {
      def to(time: Time): Interval = half(time)
      def forMinutes(minutes: Int): Interval = half(minutes)
    }
   def from(start: Time) = HalfInterval((arg: Any) => arg match {
     case delta: Int => Interval(start, start + delta)
     case end: Time  => Interval(start, end)
     case _          => throw new IllegalArgumentException
   })
}

object Time {
  def apply(hourMinute: String): Time = {
    val tries = hourMinute.split(":").map(s => Try(s.toInt))
    tries match {
      case Array(Success(hour), Success(minute)) => Time(hour, minute)
      case _ => throw new IllegalArgumentException
    }
  }
  implicit def stringToTime(hourMinute: String) = Time(hourMinute)
}

object Test extends App {
  import Interval._
  assert(from("20:30").to("20:50") == Interval("20:30", "20:50") )
  assert(from("20:30").forMinutes(10) == from("20:30").to("20:40"))
}

反向公式，其中签名比较陌生，但代码更有意义：

object Interval {
   case class HalfInterval(f: (Time=>Time) => Interval) {
      def to(end: Time): Interval = f(_ => end)
      def forMinutes(minutes: Int): Interval = f(_ + minutes)
    }
   def from(start: Time) = HalfInterval((end: Time=>Time) => Interval(start, end(start)))
}

to

和

forMinutes

都知道如何从开始时间开始创建结束时间

这使得添加例如

到（结束：时间）

，

秒（秒：Int）

变得更容易。我同意Luciano的看法，您的

半音程

有点不合常规