Using Thoughtwork's Each to implement Interaction in InteractorExample.

Created example for Each-issue ThoughtWorksInc/sde#41

Author: dominique-unruh

src/TempMacro.scala

@@ -1,6 +1,7 @@
 package trafo
 import scala.language.existentials
 import cmathml.{CMathML, CNone, Path}
+import com.thoughtworks.each.Monadic
 import misc.Pure
 import theory.Formula
 
@@ -11,6 +12,7 @@ import scala.util.control.Breaks
 import scala.runtime.BoxedUnit
 import scala.xml.Elem
 import scala.reflect.runtime.universe._
+import scalaz.Monad
 
 
 abstract class Question[T] {
@@ -94,12 +96,12 @@ final case class InteractionFinished[T](result: T) extends Interaction[T] {
   override def withFilter(p: (T) => Boolean): Interaction[T] =
     if (p(result)) this else InteractionFailed()
 }
-final case class InteractionFailed[T]() extends Interaction[T] {
-  override def resultMaybe: Option[T] = None
+final case class InteractionFailed() extends Interaction[Nothing] {
+  override def resultMaybe: Option[Nothing] = None
   override def isDone: Boolean = false
   override def isRunning: Boolean = false
   override def isFailed: Boolean = true
-  override def withFilter(p: (T) => Boolean): Interaction[T] = this
+  override def withFilter(p: Nothing => Boolean) = this
 }
 
 sealed trait Interaction[+T] {
@@ -152,7 +154,8 @@ sealed trait Interaction[+T] {
 }
 
 object Interaction {
-  def fail[T] = new InteractionFailed[T]()
+  def fail = new InteractionFailed()
+  def failU : Interaction[Unit] = fail
   def returnval[T](res : T) = new InteractionFinished[T](res)
   def ask[T<:AnyRef](id : String, question : Question[T]) =
     new InteractionRunning[T](id,question, { a =>
@@ -162,7 +165,16 @@ object Interaction {
     })
   def error(id:String,err:Elem) : Interaction[Unit] =
     new InteractionRunning[Unit](id,MessageQ.Error(err),{a=>returnval(())})
-  def failWith[T](id:String, err:Elem) : Interaction[T] =
-    for { _ <- error(id, err); res <- fail[T] } yield res
+  def failWith(id:String, err:Elem) : Interaction[Nothing] =
+    for { _ <- error(id, err); res <- fail } yield res
+  def failWithU(id:String, err:Elem) : Interaction[Unit] = failWith(id,err)
   val skip : Interaction[Unit] = returnval(())
+
+  implicit object interactionInstance extends Monad[Interaction] {
+    override def bind[A, B](fa: Interaction[A])(f: (A) => Interaction[B]): Interaction[B] = fa.flatMap(f)
+    override def point[A](a: => A): Interaction[A] = returnval(a)
+  }
+
+  val interaction = Monadic.monadic[Interaction]
 }
+

src/trafo/Interaction.scala

@@ -221,7 +221,7 @@ object Interactor {
         case _:NumberFormatException => /*valueProperty.setValue(None)*/ ()
       })
     valueProperty.addListener({ (newVal:Integer) =>
-      println("change: ",newVal)
+      Log.debug("change: ",newVal)
       textProperty.setValue(newVal.toString)})
   }
 

src/ui/Interactor.scala

@@ -45,12 +45,12 @@ class InteractionTest extends UnitSpec {
   }
 
   test("fail in for (last step)") {
-    val int : Interaction[Integer] = for { i <- Interaction.fail[Integer] } yield i
+    val int : Interaction[Integer] = for { i <- Interaction.fail } yield i
     assert(isFailed(int))
   }
 
   test("fail in for (prev step)") {
-    val int = for { i <- Interaction.fail[String]; j <- returnval(3 : Integer) } yield j
+    val int = for { i <- Interaction.fail; j <- returnval(3 : Integer) } yield j
     assert(isFailed(int))
   }
 

test/Temp.scala

@@ -0,0 +1,14 @@
+import scalaz._
+import Scalaz._
+import com.thoughtworks.each.Monadic._
+
+object MonadicNeedsCast {
+  def main(args: Array[String]): Unit = {
+    val monad = monadic[Option] {
+      None.each // Normally, this would be inside an if and represent a failure of the computation
+//      (None:Option[Unit]).each // This one works
+      55
+    }
+    println(monad) // Should be None
+  }
+}

test/trafo/InteractionTest.scala

@@ -1,35 +1,56 @@
 package ui
 
+import scalaz._
+import Scalaz._
 import javafx.animation.{KeyFrame, Timeline}
 import javafx.event.ActionEvent
 import javafx.util
 
+import com.thoughtworks.each.Monadic._
+import misc.Log
 import misc.Utils.ImplicitConversions._
 import trafo.Interaction._
 import trafo.{IntQ, Interaction, StringQ}
 
+import scala.language.postfixOps
+
 object InteractorExample {
+//  implicit object interactionInstance extends Monad[Interaction] {
+//    override def bind[A, B](fa: Interaction[A])(f: (A) => Interaction[B]): Interaction[B] = fa.flatMap(f)
+//    override def point[A](a: => A): Interaction[A] = returnval(a)
+//  }
+//  implicit object seqTraverse extends Traverse[Seq] {
+//    override def traverseImpl[F[_], A, B](l: Seq[A])(f: (A) => F[B])(implicit applicative: Applicative[F]): F[Seq[B]] =
+//      listInstance.traverseImpl(l.toList)(f)
+//  }
+//  listInstance
+  // MonadPlus[Interactor] /* with IsEmpty[Interactor] */ =
+
+
   def main(args: Array[String]) = {
     TestFxApp.run {
-      def manyQ(i:Int, j:Int=1) : Interaction[List[String]] = i match {
-        case 0 => returnval(List.empty)
-        case _ if i >= 0 =>
-          for {x <- ask("i" + j, new StringQ(<span>String nr. <b>{j}</b></span>))
-               xs <- manyQ(i - 1, j + 1)
-        } yield x :: xs
+      val int = interaction {
+        val i : Int = ask("int", new IntQ(<span>Nr 1?</span>)).each
+        if (i>10) failWithU("i>10", <span>i must be at most 10</span>).each
+        val strs = for (j <- (1 to i).toList.monadicLoop) yield
+          ask("i" + j, new StringQ(<span>String nr. <b>{j}</b></span>)).each
+
+        if (strs.contains("")) failU.each
+        ""+i+"#"+strs.mkString(",")
       }
 
-      val int = for {i <- ask("int", new IntQ(<span>Nr 1?</span>))
-                     strs <- manyQ(i)
-                     _ <- if (strs.contains("")) fail else returnval(())
-      } yield ""+i+"#"+strs.mkString(",")
+      val xxx = monadic[List] {
+        val i = (Nil:List[Unit]).each
+        55
+      }
 
       val actor = new Interactor(int)
 //      actor.setAnswer(0,"hello")
+      Log.info("initial result",actor.result)
 
-      actor.setAnswer(0,-1.asInstanceOf[Integer])
+      actor.result.onChange { (_,_,res) => Log.info("result",res) }
 
-      actor.result.onChange { (_,_,res) => println(res) }
+      actor.setAnswer(0,-1.asInstanceOf[Integer])
 
       val timeline = new Timeline(
         new KeyFrame(util.Duration.millis(1000), {(_:ActionEvent) => actor.setAnswer(0,1.asInstanceOf[Integer])}),