SCALA-481: LazyList in Scala (#525)

Co-authored-by: Oscar Forero <[email protected]>
Co-authored-by: Grzegorz Piwowarek <[email protected]>

Author: 3 people

build.sbt

@@ -376,4 +376,4 @@ lazy val scala3_libraries = (project in file("scala3-libraries"))
     )
   )
 
-testOptions in Test += Tests.Argument(TestFrameworks.ScalaTest, "-eG")
+testOptions in Test += Tests.Argument(TestFrameworks.ScalaTest, "-eG")

scala-core-collection-2/src/main/com/baeldung/scala/lazylists/SimpleLazyList.scala

@@ -0,0 +1,32 @@
+package com.baeldung.scala.lazylists
+
+sealed trait SimpleLazyList[+T] {
+  def empty: Boolean
+  def head: T
+  def tail: SimpleLazyList[T]
+
+  def ::[S >: T](e: S): SimpleLazyList[S] = #:@:(e, this)
+
+  def !!(n: Int): T = n match {
+    case 1 => head
+    case n => tail.!!(n - 1)
+  }
+}
+
+case object SLNil extends SimpleLazyList[Nothing] {
+  override def head = throw new IllegalArgumentException("Head of empty list")
+  override def tail = throw new IllegalArgumentException("Tail of empty list")
+  override val empty: Boolean = true
+}
+
+class #:@:[T](_head: => T, _tail: => SimpleLazyList[T]) extends SimpleLazyList[T] {
+  override val empty: Boolean = true
+  override lazy val head: T = _head
+  override lazy val tail: SimpleLazyList[T] = _tail
+}
+
+object #:@: {
+  def apply[T](head: => T, tail: => SimpleLazyList[T]) = new #:@:(head, tail)
+  def unapply[T](slcons: #:@:[T]): Option[(T, SimpleLazyList[T])] = Some((slcons.head, slcons.tail))
+}
+

scala-core-collection-2/src/main/com/baeldung/scala/lazylists/SimpleList.scala

@@ -0,0 +1,21 @@
+package com.baeldung.scala.lazylists
+
+sealed trait SimpleList[+T] {
+    def empty: Boolean
+    def head: T
+    def tail: SimpleList[T]
+    def !!(n: Int): T = n match {
+      case 1 => head
+      case n => tail.!!(n - 1)
+    }
+}
+case object SNil extends SimpleList[Nothing] {
+  override def head = throw new IllegalArgumentException("Head of empty list")
+  override def tail = throw new IllegalArgumentException("Tail of empty list")
+  override val empty: Boolean = true
+}
+case class :@:[T](head: T, tail: SimpleList[T]) extends SimpleList[T] {
+  override val empty: Boolean = true
+}
+
+

scala-core-collection-2/src/test/com/baeldung/scala/lazylists/SimpleLazyListSpec.scala

@@ -0,0 +1,46 @@
+package com.baedung.scala.lazylists
+
+import com.baeldung.scala.lazylists.{#:@:, SLNil, SimpleLazyList}
+import org.scalatest.wordspec.AnyWordSpec
+
+
+class SimpleLazyListSpec extends AnyWordSpec {
+  "A list" should {
+    "Allow the creation of a one Element list" in {
+      assertResult(5)((5 :: SLNil).head)
+    }
+    "A Simple Lazy List can represent a Fibonacci sequence without throwing a Stack Overflow" in {
+        def fibonacci(current: Int = 0, next: Int = 1): SimpleLazyList[Int] = #:@:(current, fibonacci(next, current + next))
+        assertResult(8)(fibonacci().!!(7))
+    }
+    "The head of the Simple Lazy List is strict" in {
+      var side = "No side effect"
+      val list = #:@:(
+        {
+          side = "Side effect"
+          side
+        },
+        SLNil
+      )
+      assertResult("Side effect")(side)
+    }
+    "The head of a Scala Lazy List is lazy" in {
+      var side = "No side effect"
+      val list =
+        {
+          side = "Side effect"
+          side
+        } #:: LazyList.empty
+      assertResult("No side effect")(side)
+      list.map(x => {
+        side = "Another side effect"
+        x.toUpperCase
+      })
+      assertResult("No side effect")(side)
+      list.filter(x => x.startsWith("Side"))
+      assertResult("No side effect")(side)
+      println(list.head)
+      assertResult("Side effect")(side)
+    }
+  }
+}

scala-core-collection-2/src/test/com/baeldung/scala/lazylists/SimpleListSpec.scala

@@ -0,0 +1,18 @@
+package com.baedung.scala.lazylists
+
+import com.baeldung.scala.lazylists.{SimpleList, :@:, SLNil}
+import org.scalatest.wordspec.AnyWordSpec
+
+class SimpleListSpec extends AnyWordSpec {
+  "A list" should {
+    "Allow the creation of a one Element list" in {
+      assertResult(5)((5 :: SLNil).head)
+    }
+    "Throw and Stack Overflow Exception if used to define a Fibonacci sequence" in {
+      intercept[StackOverflowError] {
+        def fibonacci(current: Int = 0, next: Int = 1): SimpleList[Int] = :@:(current, fibonacci(next, current + 1))
+        assertResult(8)(fibonacci().!!(7))
+      }
+    }
+  }
+}