State monad

Author: ZH11

.idea/dictionaries/pabloperezgarcia.xml

@@ -72,6 +72,7 @@ All the most common features of Observable
 * **[Functor](scala_features/src/main/scala/app/impl/scalaz/FunctorFeature.scala)**
 * **[Monad laws](scala_features/src/main/scala/app/impl/scalaz/MonadLaws.scala)**
 * **[Free monads](scala_features/src/main/scala/app/impl/scalaz/FreeMonad.scala)**
+* **[Writer monad](scala_features/src/main/scala/app/impl/scalaz/WriterMonad.scala)**
 * **[Reader monad](scala_features/src/main/scala/app/impl/scalaz/ReaderMonad.scala)**
 * **[State monad](scala_features/src/main/scala/app/impl/scalaz/StateMonad.scala)**
 * **[Monad transformer](scala_features/src/main/scala/app/impl/scalaz/MonadTransformer.scala)**

README.md

@@ -3,67 +3,83 @@ package app.impl.scalaz
 import org.junit.Test
 
 /**
-  * Created by pabloperezgarcia on 09/11/2017.
+  * Created by pabloperezgarcia on 09/11/2017..
+  *
+  * With Scalaz writer patter basically we can create our own builder patter.
+  *
+  * Applying the flatMap function we receive a type class which we append the old value with the new value, giving us
+  * a last type class with all appended values.
+  *
+  * We create our monoids which using also type class pattern we can give the implementation depending the type class we use.
   */
 class WriterMonad {
 
-  case class Writer[A, D](value: A, diary: D)(implicit m: MonadId[D]) {
+  case class Writer[A, D](value: A, appendValue: D)(implicit m: Monoid[D]) {
 
     def flatMap[B](f: A => Writer[B, D]) = f(value) match {
-      case Writer(result, d) => Writer(result, m.append(diary, d))
+      case Writer(result, newAppendValue) =>
+        Writer(result, m.append(appendValue, newAppendValue))
     }
 
-    def map[B](f: A => B) = Writer[B, D](f(value), diary)
+    def map[B](f: A => B) = Writer[B, D](f(value), appendValue)
   }
 
-  trait MonadId[T] {
+  trait Monoid[T] {
     def zero: T
 
     def append(a: T, b: T): T
   }
 
-  object MonadId {
-    implicit val StringMonoid = new MonadId[String] {
+  object Monoid {
+    implicit val StringMonoid = new Monoid[String] {
       override def zero = ""
 
       override def append(s1: String, s2: String) = s1 + s2
     }
 
-    implicit val IntMonoid = new MonadId[Int] {
+    implicit val IntMonoid = new Monoid[Int] {
       override def zero = 0
 
-      override def append(s1: Int, s2: Int) = s1 * s2
+      override def append(s1: Int, s2: Int) = s1 + s2
     }
 
-    implicit val FooMonoid = new MonadId[Foo] {
+    implicit val FooMonoid = new Monoid[Foo] {
       override def zero = Foo("")
 
-      override def append(s1: Foo, s2: Foo) = Foo(s1.value.concat(s2.value))
+      override def append(s1: Foo, s2: Foo) = Foo(s1.value + s2.value)
     }
   }
 
   @Test
   def stringWriter(): Unit = {
-    val result = Writer(5, "")
-      .flatMap(num => Writer(num + 3, "added three"))
-    println(result.value)
-    println(result.diary)
+    val result = Writer(0, "")
+      .flatMap(num => Writer(num + 1, " page 1"))
+      .flatMap(num => Writer(num + 1, " page 2"))
+      .flatMap(num => Writer(num + 1, " page 3"))
+    println(s"Total number of pages:${result.value}")
+    println(result.appendValue)
   }
 
   @Test
   def intWriter(): Unit = {
-    val result = Writer(5, 5)
-      .flatMap(num => Writer(num + 5, 10))
+    val result = Writer(1, 1)
+      .flatMap(num => Writer(num + 1, 10))
+      .flatMap(num => Writer(num + 1, 20))
+      .flatMap(num => Writer(num + 1, 30))
+      .flatMap(num => Writer(num + 1, 40))
     println(result.value)
-    println(result.diary)
+    println(result.appendValue)
   }
 
   @Test
   def fooWriter(): Unit = {
-    val result = Writer(Foo("hello"), Foo(" writer"))
+    val result = Writer(Foo(""), Foo(""))
+      .flatMap(foo => Writer(foo, Foo(" hello")))
+      .flatMap(foo => Writer(foo, Foo(" writer")))
+      .flatMap(foo => Writer(foo, Foo(" monad")))
       .flatMap(foo => Writer(foo, Foo(" world")))
     println(result.value)
-    println(result.diary)
+    println(result.appendValue)
   }
 
   case class Foo(value: String)