Merge pull request #540 from Atry/let-each-great-again

Rename FromIterable to Each for consistency with Dsl.scala 1.x

Author: Atry

Dsl/src/main/scala/com/thoughtworks/dsl/Dsl.scala

@@ -114,7 +114,7 @@ object Dsl extends LowPriorityDsl0 {
   /** The AST returned from a `for`...`yield` or a `for`...`do` expression.
     *
     * Note that a [[For]] does not directly support !-notation.
-    * Instead, [[keywords.FromIterable.ToView]] is used to convert a [[For]] to a
+    * Instead, [[keywords.Each.ToView]] is used to convert a [[For]] to a
     * [[Keyword]] that supports !-notation.
     */
   sealed trait For

README.md

@@ -24,7 +24,7 @@ We also provide some built-in keywords, including:
  * The `NullSafe` keyword for the null safe operator, similar to the `?` operator in Kotlin and Groovy.
  * The `NoneSafe` keyword for the `None` safe operator, similar to the `Maybe` monad in Haskell.
 
-All the above keywords can be used together with each others. For example you can perform list comprehension to manipulate native resources in an asynchronous task by using `FromIterable`, `Using` and `Shift` together.
+All the above keywords can be used together with each others. For example you can perform list comprehension to manipulate native resources in an asynchronous task by using `Each`, `Using` and `Shift` together.
 
 ## Getting Started
 

build.sbt

@@ -34,13 +34,12 @@ lazy val `domains-Task` =
       `keywords-Shift`,
       reset,
       `domains-Continuation`,
-      `keywords-FromIterable` % Test,
       `keywords-Using` % Test,
       `keywords-Yield` % Test,
-      `keywords-FromIterable` % Test
+      `keywords-Each` % Test
     )
 
-lazy val `keywords-FromIterable` =
+lazy val `keywords-Each` =
   crossProject(JSPlatform, JVMPlatform)
     .crossType(CrossType.Pure)
     .dependsOn(Dsl, reset % Test, `keywords-Pure`, `keywords-FlatMap`)
@@ -116,9 +115,8 @@ lazy val `keywords-AsynchronousIo` =
     .crossType(CrossType.Pure)
     .dependsOn(
       `keywords-Shift`,
-      `keywords-FromIterable` % Test,
+      `keywords-Each` % Test,
       `keywords-Using` % Test,
-      `keywords-FromIterable` % Test,
       `domains-Task` % Test
     )
 
@@ -153,7 +151,7 @@ lazy val `keywords-Await` =
       `keywords-Get` % Test,
       `keywords-Return` % Test,
       `keywords-Yield` % Test,
-      `keywords-FromIterable` % Test
+      `keywords-Each` % Test
     )
 
 lazy val `scala-async` =
@@ -167,7 +165,7 @@ lazy val `keywords-Yield` =
     .dependsOn(
       Dsl,
       reset % Test,
-      `keywords-FromIterable` % Test,
+      `keywords-Each` % Test,
       `keywords-Shift` % Test,
     )
 

domains-Task/.jvm/src/test/scala/com/thoughtworks/dsl/domains/taskSpec.scala

@@ -6,7 +6,7 @@ import com.thoughtworks.dsl.Dsl.{!!}
 import org.scalatest.Assertion
 import scala.language.implicitConversions
 
-import com.thoughtworks.dsl.keywords.{Using, FromIterable}
+import com.thoughtworks.dsl.keywords.{Using, Each}
 import com.thoughtworks.dsl.domains._
 import com.thoughtworks.dsl.keywords.Shift
 
@@ -43,7 +43,7 @@ final class taskSpec extends AsyncFreeSpec with Matchers {
     val task1: Task[Int] = Task.now(1)
 
     val ts = *[Task]/* .join */ apply Seq {
-      !FromIterable(0 until 10) + !Shift(task1)
+      !Each(0 until 10) + !Shift(task1)
     }
 
     !Shift(ts) should be(1 until 11)
@@ -80,6 +80,19 @@ final class taskSpec extends AsyncFreeSpec with Matchers {
     !Shift(task2) should be("try: my exception")
   })
 
+  "try with Each" in {
+    val listTask = Task {
+      val x =
+        try {
+          List(10 * !Each(List(1, 2)))
+        } finally {}
+      x
+    }
+    Task.toFuture(listTask).map {
+      _ should be(List(10, 20))
+    }
+  }
+
   "empty try" in {
     val logs = ArrayBuffer.empty[String]
 
@@ -183,11 +196,11 @@ final class taskSpec extends AsyncFreeSpec with Matchers {
         t0: Task[Seq[Task[Seq[Task[Seq[Task[Seq[Float]]]]]]]]
     ): Task[Seq[Seq[Seq[Seq[Float]]]]] = {
       Task /*.join*/ apply Seq {
-        val t1 = !FromIterable(!Shift(t0))
+        val t1 = !Each(!Shift(t0))
         !Shift(Task /*.join*/ apply Seq {
-          val t2 = !FromIterable(!Shift(t1))
+          val t2 = !Each(!Shift(t1))
           !Shift(Task /*.join*/ apply Seq {
-            val t3 = !FromIterable(!Shift(t2))
+            val t3 = !Each(!Shift(t2))
             !Shift(t3)
           })
         })

domains-Task/src/main/scala/com/thoughtworks/dsl/domains/Task.scala

@@ -21,7 +21,7 @@ import scala.util.control.TailCalls.TailRec
   *
   * @template
   * @example A [[Task]] can be created from `for`-comprehension,
-  *          where [[keywords.FromIterable]] can be used together to asynchronously iterate collections.
+  *          where [[keywords.Each]] can be used together to asynchronously iterate collections.
   *
   *          For example, the above `concatenateRemoteData` downloads and concatenates data from multiple URLs.
   *
@@ -31,11 +31,11 @@ import scala.util.control.TailCalls.TailRec
   *          import com.thoughtworks.dsl.keywords._
   *          import com.thoughtworks.dsl.domains.Task
   *          import java.net.URL
-  *          def concatenateRemoteData(urls: List[URL], downloader: URL => Task[Vector[Byte]]) = FromIterable.ToView {
+  *          def concatenateRemoteData(urls: List[URL], downloader: URL => Task[Vector[Byte]]) = Each.ToView {
   *            for {
-  *              url <- FromIterable(urls)
+  *              url <- Each(urls)
   *              data <- Shift(downloader(url))
-  *              byte <- FromIterable(data)
+  *              byte <- Each(data)
   *            } yield byte
   *          }.to[Task]
   *          }}}

domains-scalaz/src/main/scala/com/thoughtworks/dsl/domains/scalaz.scala

@@ -19,7 +19,7 @@ import scala.util.control.NonFatal
   * @example [[scalaz.Free.Trampoline]] is a monadic data type that performs tail call optimization.
   *          It can be built from a `@[[Dsl.reset reset]]` code block within some [[Dsl.Keyword#unary_$bang !-notation]],
   *          similar to the [[com.thoughtworks.each.Monadic.EachOps#each each]] method in
-  *          [[https://github.com/ThoughtWorksInc/each ThoughtWorks FromIterable]].
+  *          [[https://github.com/ThoughtWorksInc/each ThoughtWorks Each]].
   *
   *          {{{
   *          import _root_.scalaz.Trampoline

keywords-AsynchronousIo/src/main/scala/com/thoughtworks/dsl/keywords/AsynchronousIo.scala

@@ -40,7 +40,7 @@ import scala.util.control.NonFatal
   *          and other keywords can be used together in the same `for` block.
   *
   *          For example, the following `cat` function contains a single `for` block to concatenate file contents.
-  *          It asynchronously iterates elements `Seq`, `ArrayBuffer` and `String` with the help of [[keywords.FromIterable]],
+  *          It asynchronously iterates elements `Seq`, `ArrayBuffer` and `String` with the help of [[keywords.Each]],
   *          managed native resources with the help of [[keywords.Using]],
   *          performs previously created `readAll` task with the help of [[keywords.Shift]],
   *          and finally converts the return type [[comprehension.ComprehensionOps.as as]] a `Task[Vector[Char]]`.
@@ -51,13 +51,13 @@ import scala.util.control.NonFatal
   *          import com.thoughtworks.dsl.domains.Task
   *          import com.thoughtworks.dsl.Dsl.to
   *          import java.net.URL
-  *          def cat(paths: Path*) = FromIterable.ToView {
+  *          def cat(paths: Path*) = Each.ToView {
   *            for {
-  *              path <- FromIterable(paths)
+  *              path <- Each(paths)
   *              channel <- Using(AsynchronousFileChannel.open(path))
   *              charBuffers <- Shift(readAll(channel))
-  *              charBuffer <- FromIterable(charBuffers)
-  *              char <- FromIterable(charBuffer.toString)
+  *              charBuffer <- Each(charBuffers)
+  *              char <- Each(charBuffer.toString)
   *            } yield char
   *          }.to[Task]
   *          }}}

keywords-Await/src/test/scala/com/thoughtworks/dsl/keywords/AwaitTest.scala

@@ -31,7 +31,7 @@ class AwaitTest extends AsyncFreeSpec with Matchers with Inside {
   type Id[A] = A
   "testComprehension1" in {
     def inner1 = for {
-      j <- FromIterable(0 until 3)
+      j <- Each(0 until 3)
     } yield 100 + j
 
     val ast1 = Await(Future(1)).flatMap { i =>
@@ -44,7 +44,7 @@ class AwaitTest extends AsyncFreeSpec with Matchers with Inside {
             Await[Int],
             Int,
             Dsl.For.Yield.Map[
-              FromIterable[Int],
+              Each[Int],
               Int,
               Int
             ],
@@ -54,20 +54,20 @@ class AwaitTest extends AsyncFreeSpec with Matchers with Inside {
 
     *[Future] {
       (!Await(
-        FromIterable.ToView(ast1).to[Future]
+        Each.ToView(ast1).to[Future]
       )).toVector should be(Vector(100, 101, 102))
     }
   }
 
   "testComprehension2" in {
     import Dsl._
     val inner2 = for {
-      j <- FromIterable(0 until 10)
+      j <- Each(0 until 10)
     } yield 111
     summon[
       inner2.type
         <:<
-          Dsl.For.Yield.Map[FromIterable[Int], Int, Int]
+          Dsl.For.Yield.Map[Each[Int], Int, Int]
     ]
     val ast2 = Await(Future(1)).flatMap { i =>
       inner2
@@ -79,7 +79,7 @@ class AwaitTest extends AsyncFreeSpec with Matchers with Inside {
             Await[Int],
             Int,
             Dsl.For.Yield.Map[
-              FromIterable[Int],
+              Each[Int],
               Int,
               Int
             ],
@@ -91,9 +91,9 @@ class AwaitTest extends AsyncFreeSpec with Matchers with Inside {
 
   "testComprehension3" in {
     import Dsl._
-    val ast3 = FromIterable.ToView.toKeyword(for {
+    val ast3 = Each.ToView.toKeyword(for {
       i <- Await(Future(1))
-      j <- FromIterable(0 until 10)
+      j <- Each(0 until 10)
     } yield 111)
     summon[
       ast3.type
@@ -102,7 +102,7 @@ class AwaitTest extends AsyncFreeSpec with Matchers with Inside {
             Await[Int],
             Int,
             FlatMap[
-              FromIterable[Int],
+              Each[Int],
               Int,
               Pure[collection.View[Int]]
             ]