scriptscalamonads.scala

val sqrt = math.sqrt _
val acos = math.acos _
val divTen = (x:Double) => x/10.0

sqrt(64.0)

divTen(8.0)

acos(0.8)

def comp[A,B,C](
  f: A => B, g: B => C): A => C =
    (a) => g(f(a))

def id[A](a:A) = a

id(1)

def compSeq[A](fs: (A => A)*): A => A =
  fs.foldRight[A=>A](id)(comp)

val f = compSeq(sqrt,divTen,acos)

f(64.0)

sqrt(-1.0)

acos(10.0)

f(200.0)

val sqrtO = (x:Double) =>
  if (x >= 0.0) Some(sqrt(x)) else None

val divTenO = (x:Double) =>
  Option(divTen(x))

val acosO = (x:Double) =>
  if (x >= -1.0 && x <= 1.0)
    Some(acos(x)) else None

sqrtO(64.0)

divTenO(8.0)

acosO(0.8)

sqrtO(-1.0)

acosO(10.0)

def compO[A,B,C](
      f: A => Option[B],
      g: B => Option[C]): A => Option[C] =
  (a) => f(a) match {
           case None => None
           case Some(b) => g(b)
         }

def idO[A](a: A): Option[A] = Some(a)

idO(1)

def compOSeq[A](
  fs: (A => Option[A])*): A => Option[A] =
    fs.foldRight[A => Option[A]](idO)(compO)

val fO = compOSeq(sqrtO,divTenO,acosO)

fO(64.0)

fO(200.0)

val sqrtL = (x:Double) =>
  if (x >= 0.0)
    List(sqrt(x),-sqrt(x)) else Nil

val divTenL = (x:Double) =>
  List(divTen(x))

val acosL = (x:Double) =>
  if (x >= -1.0 && x <= 1.0)
    List(acos(x)) else Nil

sqrtL(64.0)

acosL(0.8)

acosL(-0.8)

sqrtL(-1.0)

acosL(10.0)

def compL[A,B,C](
      f: A => List[B],
      g: B => List[C]): A => List[C] =
  (a) => {
    val bs = f(a)
    var c = List[C]()
    bs.foreach(b => c = c ++ g(b))
    c
  }

def idL[A]: A => List[A] = List(_)

idL(1)

def compLSeq[A](
  fs: (A => List[A])*): A => List[A] =
    fs.foldRight[A => List[A]](idL)(compL)

val fL = compLSeq(sqrtL,divTenL,acosL)

fL(64.0)

fL(200.0)

import language.higherKinds

trait Compose[F[_]] {

  def id[A](a: A): F[A]

  def compose[A,B,C](
    f: A => F[B], g: B => F[C]): A => F[C]

  def composeSeq[A](
    fs: (A => F[A])*): A => F[A] =
      fs.foldRight[A => F[A]](id)(compose)

}

trait Monad[M[_]] {

  def id[A](a: A): M[A]

  def compose[A,B,C](
    f: A => M[B], g: B => M[C]): A => M[C]

  def composeSeq[A](
    fs: (A => M[A])*): A => M[A] =
      fs.foldRight[A => M[A]](id)(compose)

}

implicit object optionMonad extends
                      Monad[Option] {

  def id[A](a: A): Option[A] = Some(a)

  def compose[A,B,C](
        f: A => Option[B],
        g: B => Option[C]): A => Option[C] =
    (a) => f(a) match {
             case None => None
             case Some(b) => g(b)
           }

}

def composeSeq[A,M[_]:Monad](
  fs: (A => M[A])*): A => M[A] =
    implicitly[Monad[M]].composeSeq(fs: _*)

val f2O = composeSeq(sqrtO,divTenO,acosO)

f2O(64.0)

f2O(200.0)

implicit object listMonad extends
                      Monad[List] {

  def id[A](a: A) = List(a)

  def compose[A,B,C](f: A => List[B],
        g: B => List[C]): A => List[C] =
    (a) => {
      val bs = f(a)
      var c = List[C]()
      bs.foreach(b => c = c ++ g(b))
      c
    }
}

val f2L = composeSeq(sqrtL,divTenL,acosL)

f2L(64.0)

f2L(200.0)

def f3O(a:Double) =
  sqrtO(a).flatMap( b =>
  divTenO(b).flatMap( c =>  
  acosO(c).map( d => d )))

f3O(64.0)

def f4O(a:Double) = for {
  b <- sqrtO(a)
  c <- divTenO(b)
  d <- acosO(c)
} yield d

f4O(64.0)

f4O(200.0)

def f4L(a:Double) = for {
  b <- sqrtL(a)
  c <- divTenL(b)
  d <- acosL(c)
} yield d

f4L(64.0)

f4L(200.0)