add Scala functor example

Scala/Maybe1.scala

@@ -0,0 +1,43 @@
+package maybe
+
+import scala.language.higherKinds
+
+//Functor typeclass with existential F type
+trait Functor[F[_]] {
+  def fmap[A, B](fa: F[A])(f: A => B): F[B]
+}
+
+object Functor {
+  //Summons functor instance if it is in scope
+  def apply[F[_]](implicit f: Functor[F]): Functor[F] = f
+}
+
+//Maybe typeclass that represents optional value. Value type is covariant
+sealed trait Maybe[+T]
+//Maybe child that holds value. Value type is covariant
+case class Just[+T](value: T) extends Maybe[T]
+//Maybe child that represents nothing
+case object None extends Maybe[Nothing]
+
+object Maybe {
+  //Just factory method
+  def just[T](value: T): Maybe[T] = Just(value)
+
+  //None factory method
+  def none[T]: Maybe[T] = None
+
+  //Functor implementation for Maybe
+  implicit val maybeFunctor: Functor[Maybe] = new Functor[Maybe] {
+    override def fmap[A, B](fa: Maybe[A])(f: A => B): Maybe[B] = fa match {
+      case Just(v) => Just(f(v))
+      case None    => None
+    }
+  }
+}
+
+object Main extends App {
+  println(Functor[Maybe].fmap(None)((a: Int) => a + 2))
+  //prints None
+  println(Functor[Maybe].fmap(Just("2"))(_.toInt))
+  //prints Just(2)
+}

Scala/Maybe2.scala

@@ -0,0 +1,19 @@
+package maybe
+
+import scala.language.higherKinds
+
+object FunctorSyntax {
+  //Implicit Functor operations class
+  implicit class FunctorOps[F[_], A](val obj: F[A]) extends AnyVal {
+    def fmap[B](f: A => B)(implicit functor: Functor[F]): F[B] =
+      functor.fmap(obj)(f)
+  }
+}
+
+object Maybe2 extends App {
+  import Maybe._
+  import FunctorSyntax._
+
+  print(just("2").fmap(_.toDouble).fmap(a => a + 3))
+  //prints Just(5.0)
+}