trait MonadP[F[_]] extends MonadPlus[F]
- Source
- MonadP.scala
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- MonadP
- MonadPlus
- MonadPlusParent
- ApplicativePlus
- PlusEmpty
- Plus
- Monad
- Bind
- BindParent
- Applicative
- ApplicativeParent
- Apply
- ApplyParent
- Functor
- InvariantFunctor
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- Protected
Type Members
- trait ApplicativeLaw extends scalaz.Applicative.ApplyLaw
- Definition Classes
- Applicative
- trait ApplyLaw extends scalaz.Apply.FunctorLaw
- Definition Classes
- Apply
- trait BindLaw extends scalaz.Bind.ApplyLaw
- Definition Classes
- Bind
- trait EmptyLaw extends scalaz.PlusEmpty.PlusLaw
- Definition Classes
- PlusEmpty
- trait FunctorLaw extends scalaz.Functor.InvariantFunctorLaw
- Definition Classes
- Functor
- trait InvariantFunctorLaw extends AnyRef
- Definition Classes
- InvariantFunctor
- trait MonadLaw extends scalaz.Monad.ApplicativeLaw with scalaz.Monad.BindLaw
- Definition Classes
- Monad
- trait MonadPlusLaw extends scalaz.MonadPlus.EmptyLaw with scalaz.MonadPlus.MonadLaw
- Definition Classes
- MonadPlus
- trait PlusLaw extends AnyRef
- Definition Classes
- Plus
- trait StrongMonadPlusLaw extends MonadPlusLaw
- Definition Classes
- MonadPlus
Abstract Value Members
- abstract def attempt[A](fa: F[A]): F[\/[ParseError, A]]
- abstract def bind[A, B](fa: F[A])(f: (A) => F[B]): F[B]
- Definition Classes
- Bind
- abstract def empty[A]: F[A]
- Definition Classes
- PlusEmpty
- abstract def error[A](e: ParseError): F[A]
- abstract def exit[A, B](p: types.Parser[B], a: Option[A]): F[A]
- abstract def getPrefs: F[ParserPrefs]
- abstract def missingArg[A](e: ParseError): F[A]
- abstract def plus[A](a: F[A], b: => F[A]): F[A]
- Definition Classes
- Plus
- abstract def point[A](a: => A): F[A]
- Definition Classes
- Applicative
- abstract def setContext[A](s: Option[String], p: types.ParserInfo[A]): F[Unit]
- abstract def setParser[A](s: Option[String], p: types.Parser[A]): F[Unit]
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##(): Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def ap[A, B](fa: => F[A])(f: => F[(A) => B]): F[B]
- Definition Classes
- Bind → Apply
- def ap2[A, B, C](fa: => F[A], fb: => F[B])(f: F[(A, B) => C]): F[C]
- Definition Classes
- Apply
- def ap3[A, B, C, D](fa: => F[A], fb: => F[B], fc: => F[C])(f: F[(A, B, C) => D]): F[D]
- Definition Classes
- Apply
- def ap4[A, B, C, D, E](fa: => F[A], fb: => F[B], fc: => F[C], fd: => F[D])(f: F[(A, B, C, D) => E]): F[E]
- Definition Classes
- Apply
- def ap5[A, B, C, D, E, R](fa: => F[A], fb: => F[B], fc: => F[C], fd: => F[D], fe: => F[E])(f: F[(A, B, C, D, E) => R]): F[R]
- Definition Classes
- Apply
- def ap6[A, B, C, D, E, FF, R](fa: => F[A], fb: => F[B], fc: => F[C], fd: => F[D], fe: => F[E], ff: => F[FF])(f: F[(A, B, C, D, E, FF) => R]): F[R]
- Definition Classes
- Apply
- def ap7[A, B, C, D, E, FF, G, R](fa: => F[A], fb: => F[B], fc: => F[C], fd: => F[D], fe: => F[E], ff: => F[FF], fg: => F[G])(f: F[(A, B, C, D, E, FF, G) => R]): F[R]
- Definition Classes
- Apply
- def ap8[A, B, C, D, E, FF, G, H, R](fa: => F[A], fb: => F[B], fc: => F[C], fd: => F[D], fe: => F[E], ff: => F[FF], fg: => F[G], fh: => F[H])(f: F[(A, B, C, D, E, FF, G, H) => R]): F[R]
- Definition Classes
- Apply
- def apF[A, B](f: => F[(A) => B]): (F[A]) => F[B]
- Definition Classes
- Apply
- def applicativeLaw: ApplicativeLaw
- Definition Classes
- Applicative
- val applicativePlusSyntax: ApplicativePlusSyntax[F]
- Definition Classes
- ApplicativePlus
- val applicativeSyntax: ApplicativeSyntax[F]
- Definition Classes
- Applicative
- def apply[A, B](fa: F[A])(f: (A) => B): F[B]
- Definition Classes
- Functor
- def apply10[A, B, C, D, E, FF, G, H, I, J, R](fa: => F[A], fb: => F[B], fc: => F[C], fd: => F[D], fe: => F[E], ff: => F[FF], fg: => F[G], fh: => F[H], fi: => F[I], fj: => F[J])(f: (A, B, C, D, E, FF, G, H, I, J) => R): F[R]
- Definition Classes
- Apply
- def apply11[A, B, C, D, E, FF, G, H, I, J, K, R](fa: => F[A], fb: => F[B], fc: => F[C], fd: => F[D], fe: => F[E], ff: => F[FF], fg: => F[G], fh: => F[H], fi: => F[I], fj: => F[J], fk: => F[K])(f: (A, B, C, D, E, FF, G, H, I, J, K) => R): F[R]
- Definition Classes
- Apply
- def apply12[A, B, C, D, E, FF, G, H, I, J, K, L, R](fa: => F[A], fb: => F[B], fc: => F[C], fd: => F[D], fe: => F[E], ff: => F[FF], fg: => F[G], fh: => F[H], fi: => F[I], fj: => F[J], fk: => F[K], fl: => F[L])(f: (A, B, C, D, E, FF, G, H, I, J, K, L) => R): F[R]
- Definition Classes
- Apply
- def apply2[A, B, C](fa: => F[A], fb: => F[B])(f: (A, B) => C): F[C]
- Definition Classes
- Applicative → Apply
- def apply3[A, B, C, D](fa: => F[A], fb: => F[B], fc: => F[C])(f: (A, B, C) => D): F[D]
- Definition Classes
- Apply
- def apply4[A, B, C, D, E](fa: => F[A], fb: => F[B], fc: => F[C], fd: => F[D])(f: (A, B, C, D) => E): F[E]
- Definition Classes
- Apply
- def apply5[A, B, C, D, E, R](fa: => F[A], fb: => F[B], fc: => F[C], fd: => F[D], fe: => F[E])(f: (A, B, C, D, E) => R): F[R]
- Definition Classes
- Apply
- def apply6[A, B, C, D, E, FF, R](fa: => F[A], fb: => F[B], fc: => F[C], fd: => F[D], fe: => F[E], ff: => F[FF])(f: (A, B, C, D, E, FF) => R): F[R]
- Definition Classes
- Apply
- def apply7[A, B, C, D, E, FF, G, R](fa: => F[A], fb: => F[B], fc: => F[C], fd: => F[D], fe: => F[E], ff: => F[FF], fg: => F[G])(f: (A, B, C, D, E, FF, G) => R): F[R]
- Definition Classes
- Apply
- def apply8[A, B, C, D, E, FF, G, H, R](fa: => F[A], fb: => F[B], fc: => F[C], fd: => F[D], fe: => F[E], ff: => F[FF], fg: => F[G], fh: => F[H])(f: (A, B, C, D, E, FF, G, H) => R): F[R]
- Definition Classes
- Apply
- def apply9[A, B, C, D, E, FF, G, H, I, R](fa: => F[A], fb: => F[B], fc: => F[C], fd: => F[D], fe: => F[E], ff: => F[FF], fg: => F[G], fh: => F[H], fi: => F[I])(f: (A, B, C, D, E, FF, G, H, I) => R): F[R]
- Definition Classes
- Apply
- def applyApplicative: Applicative[[α]\/[F[α], α]]
- Definition Classes
- Apply
- def applyLaw: ApplyLaw
- Definition Classes
- Apply
- val applySyntax: ApplySyntax[F]
- Definition Classes
- Apply
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def bicompose[G[_, _]](implicit arg0: Bifunctor[G]): Bifunctor[[α, β]F[G[α, β]]]
- Definition Classes
- Functor
- def bindLaw: BindLaw
- Definition Classes
- Bind
- val bindSyntax: BindSyntax[F]
- Definition Classes
- Bind
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def compose[G[_]](implicit G0: Applicative[G]): ApplicativePlus[[α]F[G[α]]]
- Definition Classes
- ApplicativePlus → Applicative
- def compose[G[_]]: PlusEmpty[[α]F[G[α]]]
- Definition Classes
- PlusEmpty → Plus
- def compose[G[_]](implicit G0: Apply[G]): Apply[[α]F[G[α]]]
- Definition Classes
- Apply
- def compose[G[_]](implicit G0: Functor[G]): Functor[[α]F[G[α]]]
- Definition Classes
- Functor
- def counzip[A, B](a: \/[F[A], F[B]]): F[\/[A, B]]
- Definition Classes
- Functor
- def discardLeft[A, B](fa: => F[A], fb: => F[B]): F[B]
- Definition Classes
- ApplyParent
- def discardRight[A, B](fa: => F[A], fb: => F[B]): F[A]
- Definition Classes
- ApplyParent
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def filter[A](fa: F[A])(f: (A) => Boolean): F[A]
- Definition Classes
- MonadPlus
- def filterM[A](l: List[A])(f: (A) => F[Boolean]): F[List[A]]
- Definition Classes
- Applicative
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def flip: Applicative[F]
- Definition Classes
- Applicative → ApplyParent
- def forever[A, B](fa: F[A]): F[B]
- Definition Classes
- Bind → ApplyParent
- def fpair[A](fa: F[A]): F[(A, A)]
- Definition Classes
- Functor
- def fproduct[A, B](fa: F[A])(f: (A) => B): F[(A, B)]
- Definition Classes
- Functor
- def functorLaw: FunctorLaw
- Definition Classes
- Functor
- val functorSyntax: FunctorSyntax[F]
- Definition Classes
- Functor
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def icompose[G[_]](implicit G0: Contravariant[G]): Contravariant[[α]F[G[α]]]
- Definition Classes
- Functor
- def ifM[B](value: F[Boolean], ifTrue: => F[B], ifFalse: => F[B]): F[B]
- Definition Classes
- Bind
- def invariantFunctorLaw: InvariantFunctorLaw
- Definition Classes
- InvariantFunctor
- val invariantFunctorSyntax: InvariantFunctorSyntax[F]
- Definition Classes
- InvariantFunctor
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def iterateUntil[A](f: F[A])(p: (A) => Boolean): F[A]
- Definition Classes
- Monad
- def iterateWhile[A](f: F[A])(p: (A) => Boolean): F[A]
- Definition Classes
- Monad
- def join[A](ffa: F[F[A]]): F[A]
- Definition Classes
- Bind
- def lefts[G[_, _], A, B](value: F[G[A, B]])(implicit G: Bifoldable[G]): F[A]
- Definition Classes
- MonadPlusParent
- def lift[A, B](f: (A) => B): (F[A]) => F[B]
- Definition Classes
- Functor
- def lift10[A, B, C, D, E, FF, G, H, I, J, R](f: (A, B, C, D, E, FF, G, H, I, J) => R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I], F[J]) => F[R]
- Definition Classes
- Apply
- def lift11[A, B, C, D, E, FF, G, H, I, J, K, R](f: (A, B, C, D, E, FF, G, H, I, J, K) => R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I], F[J], F[K]) => F[R]
- Definition Classes
- Apply
- def lift12[A, B, C, D, E, FF, G, H, I, J, K, L, R](f: (A, B, C, D, E, FF, G, H, I, J, K, L) => R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I], F[J], F[K], F[L]) => F[R]
- Definition Classes
- Apply
- def lift2[A, B, C](f: (A, B) => C): (F[A], F[B]) => F[C]
- Definition Classes
- Apply
- def lift3[A, B, C, D](f: (A, B, C) => D): (F[A], F[B], F[C]) => F[D]
- Definition Classes
- Apply
- def lift4[A, B, C, D, E](f: (A, B, C, D) => E): (F[A], F[B], F[C], F[D]) => F[E]
- Definition Classes
- Apply
- def lift5[A, B, C, D, E, R](f: (A, B, C, D, E) => R): (F[A], F[B], F[C], F[D], F[E]) => F[R]
- Definition Classes
- Apply
- def lift6[A, B, C, D, E, FF, R](f: (A, B, C, D, E, FF) => R): (F[A], F[B], F[C], F[D], F[E], F[FF]) => F[R]
- Definition Classes
- Apply
- def lift7[A, B, C, D, E, FF, G, R](f: (A, B, C, D, E, FF, G) => R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G]) => F[R]
- Definition Classes
- Apply
- def lift8[A, B, C, D, E, FF, G, H, R](f: (A, B, C, D, E, FF, G, H) => R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H]) => F[R]
- Definition Classes
- Apply
- def lift9[A, B, C, D, E, FF, G, H, I, R](f: (A, B, C, D, E, FF, G, H, I) => R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I]) => F[R]
- Definition Classes
- Apply
- def many[A](a: F[A]): F[List[A]]
- Definition Classes
- ApplicativePlus
- def map[A, B](fa: F[A])(f: (A) => B): F[B]
- Definition Classes
- Monad → Applicative → Functor
- def mapply[A, B](a: A)(f: F[(A) => B]): F[B]
- Definition Classes
- Functor
- def monadLaw: MonadLaw
- Definition Classes
- Monad
- def monadPlusLaw: MonadPlusLaw
- Definition Classes
- MonadPlus
- val monadPlusSyntax: MonadPlusSyntax[F]
- Definition Classes
- MonadPlus
- val monadSyntax: MonadSyntax[F]
- Definition Classes
- Monad
- def monoid[A]: Monoid[F[A]]
- Definition Classes
- PlusEmpty
- def mproduct[A, B](fa: F[A])(f: (A) => F[B]): F[(A, B)]
- Definition Classes
- Bind
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def par: Par[F]
- Definition Classes
- ApplicativeParent
- def plusEmptyLaw: EmptyLaw
- Definition Classes
- PlusEmpty
- val plusEmptySyntax: PlusEmptySyntax[F]
- Definition Classes
- PlusEmpty
- def plusLaw: PlusLaw
- Definition Classes
- Plus
- val plusSyntax: PlusSyntax[F]
- Definition Classes
- Plus
- def product[G[_]](implicit G0: MonadPlus[G]): MonadPlus[[α](F[α], G[α])]
- Definition Classes
- MonadPlus
- def product[G[_]](implicit G0: ApplicativePlus[G]): ApplicativePlus[[α](F[α], G[α])]
- Definition Classes
- ApplicativePlus
- def product[G[_]](implicit G0: PlusEmpty[G]): PlusEmpty[[α](F[α], G[α])]
- Definition Classes
- PlusEmpty
- def product[G[_]](implicit G0: Plus[G]): Plus[[α](F[α], G[α])]
- Definition Classes
- Plus
- def product[G[_]](implicit G0: Monad[G]): Monad[[α](F[α], G[α])]
- Definition Classes
- Monad
- def product[G[_]](implicit G0: Bind[G]): Bind[[α](F[α], G[α])]
- Definition Classes
- Bind
- def product[G[_]](implicit G0: Applicative[G]): Applicative[[α](F[α], G[α])]
- Definition Classes
- Applicative
- def product[G[_]](implicit G0: Apply[G]): Apply[[α](F[α], G[α])]
- Definition Classes
- Apply
- def product[G[_]](implicit G0: Functor[G]): Functor[[α](F[α], G[α])]
- Definition Classes
- Functor
- final def pure[A](a: => A): F[A]
- Definition Classes
- Applicative
- def replicateM[A](n: Int, fa: F[A]): F[List[A]]
- Definition Classes
- Applicative
- def replicateM_[A](n: Int, fa: F[A]): F[Unit]
- Definition Classes
- Applicative
- def rights[G[_, _], A, B](value: F[G[A, B]])(implicit G: Bifoldable[G]): F[B]
- Definition Classes
- MonadPlusParent
- def semigroup[A]: Semigroup[F[A]]
- Definition Classes
- Plus
- def separate[G[_, _], A, B](value: F[G[A, B]])(implicit G: Bifoldable[G]): (F[A], F[B])
- Definition Classes
- MonadPlus
- def sequence[A, G[_]](as: G[F[A]])(implicit arg0: Traverse[G]): F[G[A]]
- Definition Classes
- Applicative
- def sequence1[A, G[_]](as: G[F[A]])(implicit arg0: Traverse1[G]): F[G[A]]
- Definition Classes
- Apply
- def some[A](a: F[A]): F[List[A]]
- Definition Classes
- ApplicativePlus
- def strengthL[A, B](a: A, f: F[B]): F[(A, B)]
- Definition Classes
- Functor
- def strengthR[A, B](f: F[A], b: B): F[(A, B)]
- Definition Classes
- Functor
- def strongMonadPlusLaw: StrongMonadPlusLaw
- Definition Classes
- MonadPlus
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- def traverse[A, G[_], B](value: G[A])(f: (A) => F[B])(implicit G: Traverse[G]): F[G[B]]
- Definition Classes
- Applicative
- def traverse1[A, G[_], B](value: G[A])(f: (A) => F[B])(implicit G: Traverse1[G]): F[G[B]]
- Definition Classes
- Apply
- def tuple2[A, B](fa: => F[A], fb: => F[B]): F[(A, B)]
- Definition Classes
- Apply
- def tuple3[A, B, C](fa: => F[A], fb: => F[B], fc: => F[C]): F[(A, B, C)]
- Definition Classes
- Apply
- def tuple4[A, B, C, D](fa: => F[A], fb: => F[B], fc: => F[C], fd: => F[D]): F[(A, B, C, D)]
- Definition Classes
- Apply
- def tuple5[A, B, C, D, E](fa: => F[A], fb: => F[B], fc: => F[C], fd: => F[D], fe: => F[E]): F[(A, B, C, D, E)]
- Definition Classes
- Apply
- def unite[T[_], A](value: F[T[A]])(implicit T: Foldable[T]): F[A]
- Definition Classes
- MonadPlus
- final def uniteU[T](value: F[T])(implicit T: Unapply[Foldable, T]): F[A]
- Definition Classes
- MonadPlus
- def unlessM[A](cond: Boolean)(f: => F[A]): F[Unit]
- Definition Classes
- Applicative
- def untilM[G[_], A](f: F[A], cond: => F[Boolean])(implicit G: MonadPlus[G]): F[G[A]]
- Definition Classes
- Monad
- def untilM_[A](f: F[A], cond: => F[Boolean]): F[Unit]
- Definition Classes
- Monad
- def void[A](fa: F[A]): F[Unit]
- Definition Classes
- Functor
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- def whenM[A](cond: Boolean)(f: => F[A]): F[Unit]
- Definition Classes
- Applicative
- def whileM[G[_], A](p: F[Boolean], body: => F[A])(implicit G: MonadPlus[G]): F[G[A]]
- Definition Classes
- Monad
- def whileM_[A](p: F[Boolean], body: => F[A]): F[Unit]
- Definition Classes
- Monad
- def widen[A, B](fa: F[A])(implicit ev: <~<[A, B]): F[B]
- Definition Classes
- Functor
- def xmap[A, B](fa: F[A], f: (A) => B, g: (B) => A): F[B]
- Definition Classes
- Functor → InvariantFunctor
- def xmapb[A, B](ma: F[A])(b: Bijection[A, B]): F[B]
- Definition Classes
- InvariantFunctor
- def xmapi[A, B](ma: F[A])(iso: scalaz.Isomorphism.<=>[A, B]): F[B]
- Definition Classes
- InvariantFunctor