带递归的Scala泛型

所以我有一个通用的组合词

回想一下，两个函数f和g的组合是h（x）=f（g（x））

但是现在我想使用我的compose函数递归地实现自合成迭代器组合器，其中：

def selfIter[T](f: T=>T, n: Int) = f composed with itself n times.

我试着这样做：

    def selfIter[T](f: T, n: Int): T = {
        if(n == 0) f
        else f + selfIter(f, n-1)
    }

    //TEST
    println(selfIter(compose(double, inc, 2.0), 2))

我犯了一个错误，我知道我在做一些根本错误的事情，但我不知道我需要做什么

在这种情况下，输出应该是14.0，因为第一次调用将是2（2+1）=6.0，然后第二次调用将是2（6.0+1）=14.0

---

问题：我应该如何重构我的代码，以便selfIter将自身合成f n次，直到n==0，并返回最终值

解决此类问题的最简单方法是使用Scala提供的组合器。此外，您应该首先编写要使用的函数，然后应用输入

def compose[A,B,C](f: B => C, g: A => B): A => C = g.andThen(f)
def selfIter[T](f: T=>T, n: Int): T => T = Function.chain(List.fill(n)(f))
println(selfIter(compose(double, inc), 2)(2.0))

如果无法更改撰写签名，则

def compose[A,B,C](f: B => C, g: A => B, x: A): C = f(g(x))
def selfIter[T](f: T=>T, n: Int): T => T = Function.chain(List.fill(n)(f))
println(selfIter[Double](compose(double, inc, _), 2)(2.0))

---

但是它更有意义第一个解决方案解决这类问题最简单的方法是使用Scala提供的组合器。此外，您应该首先编写要使用的函数，然后应用输入

def compose[A,B,C](f: B => C, g: A => B): A => C = g.andThen(f)
def selfIter[T](f: T=>T, n: Int): T => T = Function.chain(List.fill(n)(f))
println(selfIter(compose(double, inc), 2)(2.0))

如果无法更改撰写签名，则

def compose[A,B,C](f: B => C, g: A => B, x: A): C = f(g(x))
def selfIter[T](f: T=>T, n: Int): T => T = Function.chain(List.fill(n)(f))
println(selfIter[Double](compose(double, inc, _), 2)(2.0))

---

但是第一个解决方案更有意义

这里出现了一些问题

这个

f+selfIter（f，n-1）

表示

f

（type

T

）必须有一个

+

方法，该方法将另一个

T

作为参数。但你不想添加这些东西，你想把它们组合起来

这里有一个更简单的方法来获得你想要的结果

Stream.iterate(2.0)(compose(double, inc, _))(2)  // res0: Double = 14.0

如果您打算使用递归方法，这似乎可以实现您的目标

def selfIter[T](start:T, n:Int)(f:T=>T): T = {
  if (n < 2) f(start)
  else f(selfIter(start, n-1)(f))
}
selfIter(2.0, 2)(compose(double, inc, _))  // res0: Double = 14.0

def selfIter[T]（开始：T，n:Int）（f:T=>T）：T={
如果（n<2）f（启动）
其他f（自发光器（启动，n-1）（f））
}
selfIter（2.0,2）（compose（double，inc，)））//res0:double=14.0

这里有一些地方出了问题

这个

f+selfIter（f，n-1）

表示

f

（type

T

）必须有一个

+

方法，该方法将另一个

T

作为参数。但你不想添加这些东西，你想把它们组合起来

这里有一个更简单的方法来获得你想要的结果

Stream.iterate(2.0)(compose(double, inc, _))(2)  // res0: Double = 14.0

如果您打算使用递归方法，这似乎可以实现您的目标

def selfIter[T](start:T, n:Int)(f:T=>T): T = {
  if (n < 2) f(start)
  else f(selfIter(start, n-1)(f))
}
selfIter(2.0, 2)(compose(double, inc, _))  // res0: Double = 14.0

def selfIter[T]（开始：T，n:Int）（f:T=>T）：T={
如果（n<2）f（启动）
其他f（自发光器（启动，n-1）（f））
}
selfIter（2.0,2）（compose（double，inc，)））//res0:double=14.0

如果不允许Im更改compose函数中的任何内容，该怎么办？我该怎么做呢？递归是解释compose中第三个参数的必要工具。为什么要使用u以及它如何与这个函数一起工作。chain和list.fill如果你看一下

selfIter

方法，第一个参数的类型是T=>T，我们可以通过传递

（v:Double）=>compose（Double，inc，v）

，这相当于

compose（Double，inc，u）

如果不允许Im更改compose函数中的任何内容，该怎么办？我该怎么做呢？递归是解释compose中第三个参数的必要工具。为什么要使用u以及它如何与这个函数一起工作。chain和list.fill如果你看一下

selfIter

方法，第一个参数的类型是T=>T，我们可以通过传递

（v:Double）=>compose（Double，inc，v）

，这相当于

compose（Double，inc，u）