在Scala中实现惰性时间序列

我试图在Scala中实现一个可遍历的数据结构，它表示一个转换（由

fn

表示），在

时间间隔内
以定义的
周期
步骤转换为
初始
值。在引擎盖下，当前的工作方式是，当调用
apply（i:Ind）

尽管底层的
缓存
在技术上是可变的，但值只能计算一次，我希望此数据结构以不变的方式运行，并返回
lazytimeries的新实例

case class LazyTimeSeries[+A, B] (
  interval: TimeInterval,
  initial: A
)(private val fn: (TimeInterval, A) => (Int, LocalDate) => B) 
    extends TimeSeries[A, B]
    with GenericTraversableTemplate[(Int, (LocalDate, B)), LazyTimeSeries[A, B]]
{
    private val mapper = fn(interval, initial)
    private val cache = new mutable.HashMap[Int, (LocalDate, Eval[B])]

    private def pairAt(i: Int): (LocalDate, Eval[B]) = pairAt(i, interval(i))
    private def pairAt(i: Int, d: LocalDate): (LocalDate, Eval[B]) =
        cache.getOrElseUpdate(i, (d, Eval.later(mapper(i, d))))

    def apply(i: Int): Option[(LocalDate, B)] =
        if (i < 0 || i >= interval.size) None
        else Some(pairAt(i) match { case (d, e) => (d, e.value) })

    def foreach[U](f: ((Int, (LocalDate, B))) => U): Unit =
        interval.indices.map(i => (i, pairAt(i))).foreach({ 
            case (i, (d, e)) => e.flatMap(b => { f(i, (d, b)); Eval.later(b) })
        })

}

case类懒散时间序列[+A，B](
间隔：时间间隔，
首字母：A
)（私有值fn:（时间间隔，A）=>（Int，LocalDate）=>B）
扩展时间序列[A，B]
使用GenericTraversableTemplate[（Int，（LocalDate，B）），LazyTimeSeries[A，B]]
{
私有值映射器=fn（间隔，初始值）
private val cache=new mutable.HashMap[Int，（LocalDate，Eval[B]）]
private def pairAt（i:Int）：（LocalDate，Eval[B]）=pairAt（i，interval（i））
私有def pairAt（i:Int，d:LocalDate）：（LocalDate，Eval[B]）=
cache.getOrElseUpdate（i，（d，Eval.later（mapper（i，d）））
def apply（i:Int）：选项[（LocalDate，B）]=
如果（i<0 | | i>=interval.size）无
else Some（pairAt（i）匹配{case（d，e）=>（d，e.value）}）
def foreach[U]（f:（（Int，（LocalDate，B））=>U）：单位=
map（i=>（i，pairAt（i））.foreach（{
案例（i，（d，e））=>e.flatMap（b=>{f（i，（d，b））；Eval.later（b）}）
})
}

在任何情况下，我当前遇到的问题是，我想扩展
GenericTraversableTemplate
，但我当前遇到以下错误：

错误：（18，58）LazyTimeSeries[A，B]不接受类型参数，应为：1
使用GenericTraversableTemplate[（Int，（LocalDate，B）），LazyTimeSeries[A，B]]

我对实现
Traversable
做了一些深入的研究，但是对于类型系统以及如何最好地实现这种类型的数据结构的相应构建器，我有一点想法障碍。提前感谢您的帮助
 
lazytimeries
是一个
case类
，因此，您不能真正扩展它。您不能用另一个case类@BobDalgleish扩展一个case类。用一个常规类扩展它是很好的，您可以手动创建提取器使它像一个case类一样工作。为什么它会是一个case类呢？这意味着任何两个具有相同间隔和初始值的
LazyTimeSeries
都是相等的。
LazyTimeSeries
是一个
案例类
，因此，您不能真正扩展它。您只是不能用另一个案例类@BobDalgleish扩展案例类。用一个常规类扩展它是很好的，您可以手动创建提取器使它像一个case类一样工作。为什么它会是一个case类呢？这意味着具有相同间隔和初始值的任意两个
lazytimeries
。