Scala cats trampoline

Question

The test("ok") is copied from book "scala with cats" by Noel Welsh and Dave Gurnell pag.254 ("D.4 Safer Folding using Eval "), the code run fine, it's the trampolined foldRight

import cats.Eval
test("ok") {
val list = (1 to 100000).toList


def foldRightEval[A, B](as: List[A], acc: Eval[B])(fn: (A, Eval[B]) => Eval[B]): Eval[B] =
  as match {
    case head :: tail =>
      Eval.defer(fn(head, foldRightEval(tail, acc)(fn)))
    case Nil =>
      acc
  }

def foldRight[A, B](as: List[A], acc: B)(fn: (A, B) => B): B =
  foldRightEval(as, Eval.now(acc)) { (a, b) =>
    b.map(fn(a, _))
  }.value

val res = foldRight(list, 0L)(_ + _)

assert(res == 5000050000l)
}

The test("ko") returns same values of test("ok") for small list but for long list the value is different. Why?

test("ko") {
val list = (1 to 100000).toList

def foldRightSafer[A, B](as: List[A], acc: B)(fn: (A, B) => B): Eval[B] = as match {
  case head :: tail =>
    Eval.defer(foldRightSafer(tail, acc)(fn)).map(fn(head, _))
  case Nil => Eval.now(acc)
}

val res = foldRightSafer(list, 0)((a, b) => a + b).value

assert(res == 5000050000l)
}

`foldRightSafer(list, 0)` is folding to `Int`, not to `Long`. Should be `0L` — Oleg Pyzhcov, Feb 20 '18 at 15:06
Trivial typo. The OP forgot a single 'L' in '0L', and got an integer instead of a long. — Andrey Tyukin, Feb 21 '18 at 12:45

score 1 · Answer 1 · answered Feb 21 '18 at 12:54

This is @OlegPyzhcov's comment, converted into a community wiki answer

You forgot the L in 0L passed as second argument to foldRightSafer. Because of that, the inferred generic types of the invocation are

foldRightSafer[Int, Int]((list : List[Int]), (0: Int))((_: Int) + (_: Int))

and so your addition overflows and gives you something smaller than 2000000000 (9 zeroes, Int.MaxValue = 2147483647).

Scala cats trampoline

1 Answers1