Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
124 lines (96 sloc) 4.5 kB
package scalaz
////
/**
* Applicative Functor, described in [[http://www.soi.city.ac.uk/~ross/papers/Applicative.html Applicative Programming with Effects]]
*
* Whereas a [[scalaz.Functor]] allows application of a pure function to a value in a context, an Applicative
* also allows application of a function in a context to a value in a context (`ap`).
*
* It follows that a pure function can be applied to arguments in a context. (See `apply2`, `apply3`, ... )
*
* Applicative instances come in a few flavours:
* - All [[scalaz.Monad]]s are also `Applicative`
* - Any [[scalaz.Monoid]] can be treated as an Applicative (see [[scalaz.Monoid]]#applicative)
* - Zipping together corresponding elements of Naperian data structures (those of of a fixed, possibly infinite shape)
*
* @see [[scalaz.Applicative.ApplicativeLaw]]
*/
////
trait Applicative[F[_]] extends Apply[F] { self =>
////
def point[A](a: => A): F[A]
// alias for point
final def pure[A](a: => A): F[A] = point(a)
// derived functions
override def map[A, B](fa: F[A])(f: A => B): F[B] =
ap(fa)(point(f))
override def apply2[A, B, C](fa: => F[A], fb: => F[B])(f: (A, B) => C): F[C] =
ap2(fa, fb)(point(f))
// impls of sequence, traverse, etc
def traverse[A, G[_], B](value: G[A])(f: A => F[B])(implicit G: Traverse[G]): F[G[B]] =
G.traverse(value)(f)(this)
def sequence[A, G[_]: Traverse](as: G[F[A]]): F[G[A]] =
traverse(as)(a => a)
import std.list._
/** Performs the action `n` times, returning the list of results. */
def replicateM[A](n: Int, fa: F[A]): F[List[A]] =
listInstance.sequence(List.fill(n)(fa))(this)
/** Performs the action `n` times, returning nothing. */
def replicateM_[A](n: Int, fa: F[A]): F[Unit] =
listInstance.sequence_(List.fill(n)(fa))(this)
/** Filter `l` according to an applicative predicate. */
def filterM[A](l: List[A])(f: A => F[Boolean]): F[List[A]] =
l match {
case Nil => point(List())
case h :: t => ap(filterM(t)(f))(map(f(h))(b => t => if (b) h :: t else t))
}
/**
* Returns the given argument if `cond` is `false`, otherwise, unit lifted into F.
*/
def unlessM[A](cond: Boolean)(f: => F[A]): F[Unit] = if (cond) point(()) else void(f)
/**
* Returns the given argument if `cond` is `true`, otherwise, unit lifted into F.
*/
def whenM[A](cond: Boolean)(f: => F[A]): F[Unit] = if (cond) void(f) else point(())
/**The composition of Applicatives `F` and `G`, `[x]F[G[x]]`, is an Applicative */
def compose[G[_]](implicit G0: Applicative[G]): Applicative[({type λ[α] = F[G[α]]})#λ] = new CompositionApplicative[F, G] {
implicit def F = self
implicit def G = G0
}
/**The product of Applicatives `F` and `G`, `[x](F[x], G[x]])`, is an Applicative */
def product[G[_]](implicit G0: Applicative[G]): Applicative[({type λ[α] = (F[α], G[α])})#λ] = new ProductApplicative[F, G] {
implicit def F = self
implicit def G = G0
}
/** An `Applicative` for `F` in which effects happen in the opposite order. */
def flip: Applicative[F] = new Applicative[F] {
val F = Applicative.this
def point[A](a: => A) = F.point(a)
def ap[A,B](fa: => F[A])(f: => F[A => B]): F[B] =
F.ap(f)(F.map(fa)(a => (f: A => B) => f(a)))
override def flip = self
}
trait ApplicativeLaw extends ApplyLaw {
/** `point(identity)` is a no-op. */
def identityAp[A](fa: F[A])(implicit FA: Equal[F[A]]): Boolean =
FA.equal(ap(fa)(point((a: A) => a)), fa)
/** `point` distributes over function applications. */
def homomorphism[A, B](ab: A => B, a: A)(implicit FB: Equal[F[B]]): Boolean =
FB.equal(ap(point(a))(point(ab)), point(ab(a)))
/** `point` is a left and right identity, F-wise. */
def interchange[A, B](f: F[A => B], a: A)(implicit FB: Equal[F[B]]): Boolean =
FB.equal(ap(point(a))(f), ap(f)(point((f: A => B) => f(a))))
/** `map` is like the one derived from `point` and `ap`. */
def mapLikeDerived[A, B](f: A => B, fa: F[A])(implicit FB: Equal[F[B]]): Boolean =
FB.equal(map(fa)(f), ap(fa)(point(f)))
}
def applicativeLaw = new ApplicativeLaw {}
////
val applicativeSyntax = new scalaz.syntax.ApplicativeSyntax[F] { def F = Applicative.this }
}
object Applicative {
@inline def apply[F[_]](implicit F: Applicative[F]): Applicative[F] = F
////
implicit def monoidApplicative[M:Monoid]: Applicative[({type λ[α] = M})#λ] = Monoid[M].applicative
////
}
Jump to Line
Something went wrong with that request. Please try again.