package object hadaly {

  trait Functor[F[_]] {
    def map[A,B](fa:F[A])(f:A => B): F[B]
  }

  trait Applicative[F[_]] extends Functor[F] {
    def pure[A](a: => A): F[A]
    def ap[A,B](fa: F[A])(f: F[A => B]): F[B]

    override def map[A,B](fa: F[A])(f: A => B): F[B] = ap(fa)(pure(f))
    def <*[A,B](fa: F[A])(fb: F[B]): F[A] = fa
    def *>[A,B](fa: F[A])(fb: F[B]): F[B] = fb
    def η[A](a: => A): F[A] = pure(a)
    def <*>[A,B](fa: F[A])(f: F[A => B]): F[B] = ap(fa)(f)
  }

  trait Monad[M[_]] extends Applicative[M] {
    def bind[A,B](ma: M[A])(f: A => M[B]): M[B]

    override def map[A,B](ma: M[A])(f: A => B): M[B] = bind(ma)(a => pure(f(a)))
    override def ap[A,B](ma: M[A])(f: M[A => B]): M[B] = bind(f)(f => map(ma)(f))

    def liftM[A1,R](ma: M[A1])(f: A1 => R): M[R] = ap(ma)(pure(f))
    def liftM2[A1,A2,R](ma1: M[A1])(f: A1 => A2 => R)(ma2: M[A2]): M[R] =
      ap(ma2)(ap(ma1)(pure(f)))
  }

  trait MonadT[M[_], N[_]] extends Monad[M] {
    def lift[A](m:N[A]): M[A]
  }

  trait MonadOps[A, M[A]] {
    val value: M[A]
    def map[B](f:A => B)(implicit m:Monad[M]) = m.map(value)(f)
    def ∘[B](f:A => B)(implicit m:Monad[M]) = m.map(value)(f)
    def flatMap[B](f: A => M[B])(implicit m:Monad[M]) = m.bind(value)(f)
    def >>=[B](f: A => M[B])(implicit m:Monad[M]) = m.bind(value)(f)
    def liftM[B](f: A => B)(implicit m:Monad[M]) = m.liftM(value)(f)
    def liftM2[B,C](f: A => B => C)(m2: M[B])(implicit m:Monad[M]) = m.liftM2(value)(f)(m2)
  }

  trait MonadTOps[A, M[A], N[A]] {
    val value: M[A]
    def map[B](f:A => B)(implicit m:MonadT[M,N]) = m.map(value)(f)
    def ∘[B](f:A => B)(implicit m:MonadT[M,N]) = m.map(value)(f)
    def flatMap[B](f: A => M[B])(implicit m:MonadT[M,N]) = m.bind(value)(f)
    def >>=[B](f: A => M[B])(implicit m:MonadT[M,N]) = m.bind(value)(f)
    def liftM[B](f: A => B)(implicit m:MonadT[M,N]) = m.liftM(value)(f)
    def liftM2[B,C](f: A => B => C)(m2: M[B])(implicit m:MonadT[M,N]) = m.liftM2(value)(f)(m2)
  }

  case class Id[+A](value: A)

  trait IdImplicits {
    implicit def monadIdentity = new Monad[Id] {
      def pure[A](a: => A): Id[A] = Id(a)
      def bind[A,B](ma: Id[A])(f: A => Id[B]): Id[B] = f(ma.value)
    }
    implicit def monadIdentityOps[A](id: Id[A]) = new MonadOps[A, Id] {
      val value = id
    }
    implicit def idAToA[A](ida:Id[A]):A = ida.value
  }

  trait ListImplicits {
    implicit def monadList = new Monad[List] {
      def pure[A](a: => A) = List(a)
      def bind[A,B](ma:List[A])(f: A => List[B]) = ma.flatMap(f)}
    implicit def monadListOps[A](l: List[A]) = new MonadOps[A, List] {
      val value = l
    }
  }

  object Implicits
    extends IdImplicits
    with ListImplicits