Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

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.