State monad

Author: ZH11

Diff for: scala_features/src/main/scala/app/impl/scala/FoldFunction.scala

@@ -69,9 +69,9 @@ class FoldFunction {
   }
 
 
-
   /**
     * If someValue it´s empty fold will return the Value, otherwise it will execute the second function
+    *
     * @param mainClass
     * @param someValue
     * @return
@@ -130,4 +130,19 @@ class FoldFunction {
     }
     println(formatPath)
   }
+
+  /**
+    * Using foldRight we do the other way around of the previous test.
+    */
+  @Test
+  def foldLeftRightMap() = {
+    val map: Map[String, String] = Map()
+
+    val newMap = keyValue.foldRight(map)((entry, map) => map ++ Map(entry._1 -> entry._2))
+    println(newMap)
+
+    val newMap1 = keyValue.foldLeft(map)((map, entry) => map ++ Map(entry._1 -> entry._2))
+    println(newMap1)
+
+  }
 }

Diff for: scala_features/src/main/scala/app/impl/scala/TypeClasses.scala

@@ -37,6 +37,8 @@ class TypeClasses {
 
   implicit val stringName: TypeClass[String] = TypeClass(clazz => clazz.getClass.getName)
 
+//  implicit val longName: TypeClass[Long] = TypeClass(clazz => clazz.getClass.getName)
+
 
   def getClassName[T](className: T)(implicit typeClass: TypeClass[T]): String = {
     typeClass.className(className)

Diff for: scala_features/src/main/scala/app/impl/scalaz/TraverseFeature.scala

@@ -0,0 +1,20 @@
+package app.impl.scalaz
+
+import org.junit.Test
+
+/**
+  * Created by pabloperezgarcia on 09/11/2017.
+  */
+class TraverseFeature {
+
+  val pf: Int => Option[Int] = PartialFunction.condOpt(_) { case 3 => 30; case 4 => 40 }
+
+
+  @Test
+  def main(): Unit = {
+//    List(1, 2, 3, 4).traverse(pf)
+//    List(3, 4).traverse(pf)
+  }
+
+
+}

Diff for: scala_features/src/main/scala/app/impl/scalaz/WriterMonad.scala

@@ -0,0 +1,71 @@
+package app.impl.scalaz
+
+import org.junit.Test
+
+/**
+  * Created by pabloperezgarcia on 09/11/2017.
+  */
+class WriterMonad {
+
+  case class Writer[A, D](value: A, diary: D)(implicit m: MonadId[D]) {
+
+    def flatMap[B](f: A => Writer[B, D]) = f(value) match {
+      case Writer(result, d) => Writer(result, m.append(diary, d))
+    }
+
+    def map[B](f: A => B) = Writer[B, D](f(value), diary)
+  }
+
+  trait MonadId[T] {
+    def zero: T
+
+    def append(a: T, b: T): T
+  }
+
+  object MonadId {
+    implicit val StringMonoid = new MonadId[String] {
+      override def zero = ""
+
+      override def append(s1: String, s2: String) = s1 + s2
+    }
+
+    implicit val IntMonoid = new MonadId[Int] {
+      override def zero = 0
+
+      override def append(s1: Int, s2: Int) = s1 * s2
+    }
+
+    implicit val FooMonoid = new MonadId[Foo] {
+      override def zero = Foo("")
+
+      override def append(s1: Foo, s2: Foo) = Foo(s1.value.concat(s2.value))
+    }
+  }
+
+  @Test
+  def stringWriter(): Unit = {
+    val result = Writer(5, "")
+      .flatMap(num => Writer(num + 3, "added three"))
+    println(result.value)
+    println(result.diary)
+  }
+
+  @Test
+  def intWriter(): Unit = {
+    val result = Writer(5, 5)
+      .flatMap(num => Writer(num + 5, 10))
+    println(result.value)
+    println(result.diary)
+  }
+
+  @Test
+  def fooWriter(): Unit = {
+    val result = Writer(Foo("hello"), Foo(" writer"))
+      .flatMap(foo => Writer(foo, Foo(" world")))
+    println(result.value)
+    println(result.diary)
+  }
+
+  case class Foo(value: String)
+
+}