Fix Streaming#memoization.

core/src/main/scala/cats/data/Streaming.scala

@@ -642,14 +642,21 @@ sealed abstract class Streaming[A] extends Product with Serializable { lhs =>
    * Ensure that repeated traversals of the stream will not cause
    * repeated tail computations.
    *
-   * By default stream does not memoize to avoid memory leaks when the
-   * head of the stream is retained.
+   * By default this structure does not memoize to avoid memory leaks
+   * when the head of the stream is retained. However, the user
+   * ultimately has control of the memoization approach based on what
+   * kinds of Eval instances they use.
+   *
+   * There are two calls to memoized here -- one is a recursive call
+   * to this method (on the tail) and the other is a call to memoize
+   * the Eval instance holding the tail. For more information on how
+   * .memoize works see Eval#memoize.
    */
   def memoize: Streaming[A] =
     this match {
       case Empty() => Empty()
-      case Wait(lt) => Wait(lt.memoize)
-      case Cons(a, lt) => Cons(a, lt.memoize)
+      case Wait(lt) => Wait(lt.map(_.memoize).memoize)
+      case Cons(a, lt) => Cons(a, lt.map(_.memoize).memoize)
     }
 
   /**

tests/src/test/scala/cats/tests/StreamingTests.scala

@@ -23,6 +23,24 @@ class StreamingTests extends CatsSuite {
 
 class AdHocStreamingTests extends CatsSuite {
 
+  test("results aren't reevaluated after memoize") {
+    forAll { (orig: Streaming[Int]) =>
+      val ns = orig.toList
+      val size = ns.size
+
+      var i = 0
+      val memoized = orig.map { n => i += 1; n }.memoize
+
+      val xs = memoized.toList
+      i should === (size)
+      xs should === (ns)
+
+      val ys = memoized.toList
+      i should === (size)
+      ys should === (ns)
+    }
+  }
+
   // convert List[A] to Streaming[A]
   def convert[A](as: List[A]): Streaming[A] =
     Streaming.fromList(as)