add cycle method to LazyList

Author: SethTisue

src/main/scala/collection/immutable/LazyListExtensions.scala

@@ -0,0 +1,32 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package scala.collection.immutable
+
+object LazyListExtensions {
+
+  implicit class LazyListCycle[T](ll: LazyList[T]) {
+    /**
+     * When called on a finite `LazyList`, returns a circular structure
+     * that endlessly repeats the elements in the input.
+     * The result is a true cycle occupying only constant memory.
+     */
+    def cycle: LazyList[T] =
+      if (ll.isEmpty)
+        LazyList.empty
+      else {
+        lazy val result: LazyList[T] = ll #::: result
+        result
+      }
+  }
+
+}

src/test/scala/collection/immutable/TestLazyListExtensions.scala

@@ -0,0 +1,81 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package scala.collection.immutable
+
+import org.junit.Assert._
+import org.junit.Test
+
+import LazyListExtensions._
+
+class TestLazyListExtensions {
+  @Test
+  def testEmpty1(): Unit = {
+    val xs = LazyList.empty  // realized
+    val cyc = xs.cycle
+    assertTrue(cyc.isEmpty)
+    assertTrue(cyc.size == 0)
+    assertEquals(Nil, cyc.toList)
+  }
+  @Test
+  def testEmpty2(): Unit = {
+    val xs = LazyList()  // not realized
+    val cyc = xs.cycle
+    assertTrue(cyc.isEmpty)
+    assertTrue(cyc.size == 0)
+    assertEquals(Nil, cyc.toList)
+  }
+  @Test
+  def testNonEmpty(): Unit = {
+    val xs = LazyList(1, 2, 3)
+    val cyc = xs.cycle
+    assertFalse(cyc.isEmpty)
+    assertEquals(LazyList(1, 2, 3, 1, 2, 3, 1, 2), cyc.take(8))
+  }
+  @Test
+  def testToString(): Unit = {
+    assertEquals("LazyList()",
+      LazyList.empty.cycle.toString)
+    assertEquals("LazyList(<not computed>)",
+      LazyList(1, 2, 3).cycle.toString)
+    // note cycle detection here!
+    assertEquals("LazyList(1, 2, 3, <cycle>)",
+      LazyList(1, 2, 3).cycle.force.toString)
+  }
+  @Test
+  def testRepeats(): Unit = {
+    val xs = LazyList(1, 2, 3)
+    val cyc = xs.cycle
+    assertFalse(cyc.isEmpty)
+    assertEquals(LazyList(1, 2, 3, 1, 2, 3, 1, 2), cyc.take(8))
+  }
+  @Test
+  def testConstantMemory1(): Unit = {
+    val xs = LazyList(1, 2, 3)
+    val cyc = xs.cycle
+    assertTrue(cyc.tail eq cyc.tail.tail.tail.tail)
+    assertTrue(cyc.tail eq cyc.drop(4))   // TODO: fails
+    assertTrue(cyc eq cyc.tail.tail.tail) // TODO: fails
+    assertTrue(cyc eq cyc.drop(3))        // TODO: fails
+    assertTrue(cyc eq cyc.drop(3))        // TODO: fails
+  }
+  @Test
+  def testConstantMemory2(): Unit = {
+    var counter = 0
+    def count(): Int = { counter += 1; counter }
+    val xs = count() #:: count() #:: count() #:: LazyList.empty
+    val cyc = xs.cycle
+    assertEquals(1, counter)
+    assertEquals(10, cyc.take(10).size)
+    assertEquals(3, counter)
+  }
+}