scala - 项目Euler＃2的Scala无形代码

我已经开始对Project Euler Problem #2进行Shapeless解决方案。

我可以将所有偶数求和到Nth的总和，甚至与此代码相加:

import shapeless._, nat._, ops.nat.Sum

trait Fibonacci[N <: Nat] { type Out <: Nat }

object Fibonacci {
  type Aux[N <: Nat, Out0 <: Nat] = Fibonacci[N] { type Out = Out0 }

  def apply[N <: Nat](i: Nat)(implicit fib: Aux[i.N, N], n: Witness.Aux[N]):N = n.value

  implicit val fib0 = new Fibonacci[_0] { type Out = _2 }
  implicit val fib1 = new Fibonacci[_1] { type Out = _3 }

  implicit def fibN[I <: Nat, L <: Nat, M <: Nat](implicit l: Aux[I, L],
                                                  m: Aux[Succ[I], M],
                                                  sum: Sum[L, M]) =
    new Fibonacci[Succ[Succ[I]]] { type Out = sum.Out }
}

trait Fibs[N <: Nat] { type Out <: Nat }

object Fibs {
  type Aux[N <: Nat, Out0 <: Nat] = Fibs[N] { type Out = Out0 }

  def apply[N <: Nat](i: Nat)(implicit fibs: Aux[i.N, N], n: Witness.Aux[N]):N = n.value

  implicit def fibs0(implicit f: Fibonacci[_0]) = new Fibs[_0] { type Out = f.Out }

  implicit def fibsN[N <: Nat, R <: Nat, Z <: Nat](implicit fib: Fibonacci.Aux[Succ[Succ[Succ[N]]], R],
                                                   fibs: Aux[N, Z],
                                                   sum: Sum[R, Z]) =
    new Fibs[Succ[N]] {
      type Out = sum.Out
    }
}

现在我可以做:

val (evenFibs0, evenFibs1) = (Fibs(0), Fibs(1))
typed[_2](evenFibs0)
typed[_10](evenFibs1)

这就是我得到所有偶数纤维的方式:我从序列2、3，...开始，然后对每三个斐波纳契数进行求和。

现在，我被困住了。我想要具有类似于takeWhile的功能，因此我可以编写一个接受limit并返回其项未超过该限制的偶数和的总和的函数。有任何想法吗？

这是到目前为止我所做的努力:

trait EvenFibsWithLimit[N <: Nat, M <: Nat] { type Out <: Nat }

trait LowPriorityFibs3 {
  type Aux[N <: Nat, M <: Nat, Out0 <: Nat] = EvenFibsWithLimit[N, M] { type Out = Out0 }

  implicit def fibs0[M <: Nat] = new EvenFibsWithLimit[_0, M] { type Out = _0 }

  implicit def fibsGT[N <: Nat, M <: Nat, O <: Nat](implicit f: EvenFibsWithLimit[N, M],
                                                    fib: Fibs.Aux[N, O],
                                                    l: ops.nat.LT[M, O]) = f
}

object EvenFibsWithLimit extends LowPriorityFibs3 {
  def apply[N <: Nat, O <: Nat](limit: Nat)(implicit fibs: Aux[N, limit.N, O],
                                            o: Witness.Aux[O]): O = o.value

  implicit def fibsN[N <: Nat, M <: Nat, O <: Nat](implicit f: EvenFibsWithLimit[N, M],
                                                   f2: Fibs.Aux[Succ[N], O],
                                                   d: ops.nat.Diff[M, O]) =
    new EvenFibsWithLimit[Succ[N], d.Out] {
      type Out = O
    }
}

想法是通过输出递归减去限制，直到输出小于限制为止。我绝对可以闻到有什么问题。我认为我根本不需要Diff。.我也尝试了其他一些变体，但是我一直陷于困境。编译时出现错误diverging implicit expansion for fibsN.
编辑:

我当时在想，也许我可以构造自己的HList的Fibs，并使用带有谓词类型类的Selector来模拟takeWhile。有什么想法吗？

最佳答案

我发现解决此类问题的最佳方法是逐步考虑自然数，同时考虑需要跟踪的信息。

在纸上，我将使用以下内容:

N  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
C  1  2  3  3  5  5  5  8  8  8  8  8 13 13 13
P  1  1  2  2  3  3  3  5  5  5  5  5  8  8  8
L  0  2  2  2  2  2  2 10 10 10 10 10 10 10 10

这里C跟踪斐波纳契序列中的当前数字，即小于或等于N的最大的。 P是之前的斐波那契数，而L是到目前为止我们所看到的偶数的和。

我们可以将其转换为类型类:

import shapeless._, ops.nat.{ Mod, Sum }, nat.{ _0, _1, _2 }

trait EvenFibs[N <: Nat] {
  type L <: Nat
  type C <: Nat
  type P <: Nat
}

现在，我们需要处理四种情况。首先，我将给出优先级最低的选项，以便获得正确的隐式分辨率:

trait LowPriorityEvenFibs {
  type Aux[N <: Nat, L0 <: Nat, C0 <: Nat, P0 <: Nat] = EvenFibs[N] {
    type L = L0
    type C = C0
    type P = P0
  }

  implicit def ef3[N <: Nat](implicit
    ef: EvenFibs[N]
  ): Aux[Succ[N], ef.L, ef.C, ef.P] = new EvenFibs[Succ[N]] {
    type L = ef.L
    type C = ef.C
    type P = ef.P
  }
}

在这种情况下，Succ[N]不是斐波那契数。它不需要我们更新我们一直在跟踪的任何值。接下来的情况要复杂一些:

trait MidPriorityEvenFibs extends LowPriorityEvenFibs {
  implicit def ef2[N <: Nat, L0 <: Nat, PP <: Nat, P0 <: Nat](implicit
    ef: Aux[N, L0, P0, PP],
    sum: Sum.Aux[PP, P0, Succ[N]]
  ): Aux[Succ[N], L0, Succ[N], P0] = new EvenFibs[Succ[N]] {
    type L = L0
    type C = Succ[N]
    type P = P0
  }
}

在这种情况下，Succ[N]是一个奇数的斐波那契数。在这种情况下，我们需要更新C和P，而不是L。

我们最后一个Succ[N]情况是Succ[N]是偶数斐波那契数的情况。我将在这里以基本情况为例:

object EvenFibs extends MidPriorityEvenFibs {
  implicit def ef0: Aux[_0, _0, _1, _1] = new EvenFibs[_0] {
    type L = _0
    type C = _1
    type P = _1
  }

  implicit def ef1[N <: Nat, L <: Nat, PP <: Nat, P0 <: Nat](implicit
    ef: Aux[N, L, P0, PP],
    sum: Sum.Aux[PP, P0, Succ[N]],
    mod: Mod.Aux[Succ[N], _2, _0],
    current: Sum[Succ[N], L]
  ): Aux[Succ[N], current.Out, Succ[N], P0] = new EvenFibs[Succ[N]] {
    type L = current.Out
    type C = Succ[N]
    type P = P0
  }

  def apply[N <: Nat](implicit ef: EvenFibs[N]): Aux[N, ef.L, ef.C, ef.P] = ef
}

最后，我们可以定义一个帮助程序类，这将使检查工作变得更加容易:

class ComputeHelper[N <: Nat] {
  def value[L <: Nat, C <: Nat, P <: Nat](implicit
    ef: EvenFibs.Aux[N, L, C, P],
    wit: Witness.Aux[L]
  ): L = wit.value
}

def compute[N <: Nat]: ComputeHelper[N] = new ComputeHelper[N]

进而:

test.typed[_0](compute[_0].value)
test.typed[_0](compute[_1].value)
test.typed[_2](compute[_2].value)
test.typed[_2](compute[nat._3].value)
test.typed[_2](compute[nat._4].value)
test.typed[_2](compute[nat._5].value)
test.typed[_2](compute[nat._6].value)
test.typed[_2](compute[nat._7].value)
test.typed[nat._10](compute[nat._8].value)
test.typed[nat._10](compute[nat._9].value)

最后一行在我的计算机上编译大约需要20秒，但是可以正常工作。

关于scala - 项目Euler＃2的Scala无形代码，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/31615371/