optparse-applicative/optparse_applicative.internal/MonadP

MonadP

trait MonadP[F[_]] extends MonadPlus[F]
trait MonadPlus[F]
trait ApplicativePlus[F]
trait PlusEmpty[F]
trait Plus[F]
trait Monad[F]
trait Bind[F]
trait Applicative[F]
trait InvariantApplicative[F]
trait Apply[F]
trait Functor[F]
trait InvariantFunctor[F]
class Object
trait Matchable
class Any

Type members

Inherited classlikes

abstract trait ApplicativeLaw
Inherited from
Applicative
abstract trait ApplyLaw
Inherited from
Apply
abstract trait BindLaw
Inherited from
Bind
abstract trait EmptyLaw
Inherited from
PlusEmpty
abstract trait FunctorLaw
Inherited from
Functor
abstract trait InvariantFunctorLaw
Inherited from
InvariantFunctor
abstract trait MonadLaw
Inherited from
Monad
abstract trait MonadPlusLaw
Inherited from
MonadPlus
abstract trait PlusLaw
Inherited from
Plus
abstract trait StrongMonadPlusLaw
Inherited from
MonadPlus

Value members

Abstract methods

def attempt[A](fa: F[A]): F[ParseError \/ A]
def error[A](e: ParseError): F[A]
def exit[A, B](p: Parser[B], a: Option[A]): F[A]
def missingArg[A](e: ParseError): F[A]
def setContext[A](s: Option[String], p: ParserInfo[A]): F[Unit]
def setParser[A](s: Option[String], p: Parser[A]): F[Unit]

Inherited methods

override def ap[A, B](fa: => F[A])(f: => F[A => B]): F[B]
Definition Classes
Bind -> Apply
Inherited from
Bind
def ap2[A, B, C](fa: => F[A], fb: => F[B])(f: F[(A, B) => C]): F[C]
Inherited from
Apply
def ap3[A, B, C, D](fa: => F[A], fb: => F[B], fc: => F[C])(f: F[(A, B, C) => D]): F[D]
Inherited from
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]
Inherited from
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]
Inherited from
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]
Inherited from
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]
Inherited from
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]
Inherited from
Apply
def apF[A, B](f: => F[A => B]): F[A] => F[B]
Inherited from
Apply
def applicativeLaw: ApplicativeLaw
Inherited from
Applicative
def apply[A, B](fa: F[A])(f: A => B): F[B]
Inherited from
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]
Inherited from
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]
Inherited from
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]
Inherited from
Apply
override def apply2[A, B, C](fa: => F[A], fb: => F[B])(f: (A, B) => C): F[C]
Definition Classes
Bind -> Apply
Inherited from
Bind
def apply3[A, B, C, D](fa: => F[A], fb: => F[B], fc: => F[C])(f: (A, B, C) => D): F[D]
Inherited from
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]
Inherited from
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]
Inherited from
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]
Inherited from
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]
Inherited from
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]
Inherited from
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]
Inherited from
Apply
def applyApplicative: Applicative[[α] =>> F[α] \/ α]
Inherited from
Apply
def applyLaw: ApplyLaw
Inherited from
Apply
final def applying1[Z, A1](f: A1 => Z)(implicit a1: F[A1]): F[Z]
Inherited from
Apply
final def applying2[Z, A1, A2](f: (A1, A2) => Z)(implicit a1: F[A1], a2: F[A2]): F[Z]
Inherited from
Apply
final def applying3[Z, A1, A2, A3](f: (A1, A2, A3) => Z)(implicit a1: F[A1], a2: F[A2], a3: F[A3]): F[Z]
Inherited from
Apply
final def applying4[Z, A1, A2, A3, A4](f: (A1, A2, A3, A4) => Z)(implicit a1: F[A1], a2: F[A2], a3: F[A3], a4: F[A4]): F[Z]
Inherited from
Apply
def bicompose[G[_, _]](implicit Bifunctor[G]): Bifunctor[[α, β] =>> F[G[α, β]]]
Inherited from
Functor
def bind[A, B](fa: F[A])(f: A => F[B]): F[B]
Inherited from
Bind
def bindLaw: BindLaw
Inherited from
Bind
override def compose[G[_]](implicit G0: Applicative[G]): ApplicativePlus[[α] =>> F[G[α]]]
Definition Classes
ApplicativePlus -> Applicative
Inherited from
ApplicativePlus
override def compose[G[_]]: PlusEmpty[[α] =>> F[G[α]]]
Definition Classes
PlusEmpty -> Plus
Inherited from
PlusEmpty
def compose[G[_]](implicit G0: Apply[G]): Apply[[α] =>> F[G[α]]]
Inherited from
Apply
def compose[G[_]](implicit G0: Functor[G]): Functor[[α] =>> F[G[α]]]
Inherited from
Functor
def counzip[A, B](a: F[A] \/ F[B]): F[A \/ B]
Inherited from
Functor
def discardLeft[A, B](fa: => F[A], fb: => F[B]): F[B]
Inherited from
Apply
def discardRight[A, B](fa: => F[A], fb: => F[B]): F[A]
Inherited from
Apply
def empty[A]: F[A]
Inherited from
PlusEmpty
def filter[A](fa: F[A])(f: A => Boolean): F[A]
Inherited from
MonadPlus
def filterM[A](l: IList[A])(f: A => F[Boolean]): F[IList[A]]
Inherited from
Applicative
def filterM[A](l: List[A])(f: A => F[Boolean]): F[List[A]]
Inherited from
Applicative
def filterM[A, B](map: A ==>> B)(f: B => F[Boolean])(implicit O: Order[A]): F[A ==>> B]
Inherited from
Applicative
override def flip: Applicative[F]
Definition Classes
Applicative -> Apply
Inherited from
Applicative
def forever[A, B](fa: F[A]): F[B]
Inherited from
Apply
def fpair[A](fa: F[A]): F[(A, A)]
Inherited from
Functor
def fproduct[A, B](fa: F[A])(f: A => B): F[(A, B)]
Inherited from
Functor
def functorLaw: FunctorLaw
Inherited from
Functor
def icompose[G[_]](implicit G0: Contravariant[G]): Contravariant[[α] =>> F[G[α]]]
Inherited from
Functor
def ifM[B](value: F[Boolean], ifTrue: => F[B], ifFalse: => F[B]): F[B]
Inherited from
Bind
def invariantFunctorLaw: InvariantFunctorLaw
Inherited from
InvariantFunctor
def iterateUntil[A](f: F[A])(p: A => Boolean): F[A]
Inherited from
Monad
def iterateWhile[A](f: F[A])(p: A => Boolean): F[A]
Inherited from
Monad
def join[A](ffa: F[F[A]]): F[A]
Inherited from
Bind
def lefts[G[_, _], A, B](value: F[G[A, B]])(implicit G: Bifoldable[G]): F[A]
Inherited from
MonadPlus
def lift[A, B](f: A => B): F[A] => F[B]
Inherited from
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]
Inherited from
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]
Inherited from
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]
Inherited from
Apply
def lift2[A, B, C](f: (A, B) => C): (F[A], F[B]) => F[C]
Inherited from
Apply
def lift3[A, B, C, D](f: (A, B, C) => D): (F[A], F[B], F[C]) => F[D]
Inherited from
Apply
def lift4[A, B, C, D, E](f: (A, B, C, D) => E): (F[A], F[B], F[C], F[D]) => F[E]
Inherited from
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]
Inherited from
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]
Inherited from
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]
Inherited from
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]
Inherited from
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]
Inherited from
Apply
def liftReducer[A, B](implicit r: Reducer[A, B]): Reducer[F[A], F[B]]
Inherited from
Apply
override def map[A, B](fa: F[A])(f: A => B): F[B]
Definition Classes
Monad -> Applicative -> Functor
Inherited from
Monad
def mapply[A, B](a: A)(f: F[A => B]): F[B]
Inherited from
Functor
def monadLaw: AnyRef & MonadLaw
Inherited from
Monad
def monadPlusLaw: MonadPlusLaw
Inherited from
MonadPlus
def monoid[A]: Monoid[F[A]]
Inherited from
PlusEmpty
def mproduct[A, B](fa: F[A])(f: A => F[B]): F[(A, B)]
Inherited from
Bind
def par: Par[F]
Inherited from
Applicative
def plus[A](a: F[A], b: => F[A]): F[A]
Inherited from
Plus
def plusA[A](x: => F[A], y: => F[A])(implicit sa: Semigroup[A]): F[A]
Inherited from
Applicative
def plusEmptyLaw: EmptyLaw
Inherited from
PlusEmpty
def plusLaw: PlusLaw
Inherited from
Plus
def point[A](a: => A): F[A]
Inherited from
Applicative
def product[G[_]](implicit G0: MonadPlus[G]): MonadPlus[[α] =>> (F[α], G[α])]
Inherited from
MonadPlus
def product[G[_]](implicit G0: ApplicativePlus[G]): ApplicativePlus[[α] =>> (F[α], G[α])]
Inherited from
ApplicativePlus
def product[G[_]](implicit G0: PlusEmpty[G]): PlusEmpty[[α] =>> (F[α], G[α])]
Inherited from
PlusEmpty
def product[G[_]](implicit G0: Plus[G]): Plus[[α] =>> (F[α], G[α])]
Inherited from
Plus
def product[G[_]](implicit G0: Applicative[G]): Applicative[[α] =>> (F[α], G[α])]
Inherited from
Applicative
def product[G[_]](implicit G0: Apply[G]): Apply[[α] =>> (F[α], G[α])]
Inherited from
Apply
def product[G[_]](implicit G0: Functor[G]): Functor[[α] =>> (F[α], G[α])]
Inherited from
Functor
def product[G[_]](implicit G0: Monad[G]): Monad[[α] =>> (F[α], G[α])]
Inherited from
Monad
def product[G[_]](implicit G0: Bind[G]): Bind[[α] =>> (F[α], G[α])]
Inherited from
Bind
final def pure[A](a: => A): F[A]
Inherited from
Applicative
def replicateM[A](n: Int, fa: F[A]): F[IList[A]]
Inherited from
Applicative
def replicateM_[A](n: Int, fa: F[A]): F[Unit]
Inherited from
Applicative
def rights[G[_, _], A, B](value: F[G[A, B]])(implicit G: Bifoldable[G]): F[B]
Inherited from
MonadPlus
def semigroup[A]: Semigroup[F[A]]
Inherited from
Plus
def separate[G[_, _], A, B](value: F[G[A, B]])(implicit G: Bifoldable[G]): (F[A], F[B])
Inherited from
MonadPlus
def sequence[A, G[_]](as: G[F[A]])(implicit Traverse[G]): F[G[A]]
Inherited from
Applicative
def sequence1[A, G[_]](as: G[F[A]])(implicit Traverse1[G]): F[G[A]]
Inherited from
Apply
def strengthL[A, B](a: A, f: F[B]): F[(A, B)]
Inherited from
Functor
def strengthR[A, B](f: F[A], b: B): F[(A, B)]
Inherited from
Functor
def strongMonadPlusLaw: StrongMonadPlusLaw
Inherited from
MonadPlus
def traverse[A, G[_], B](value: G[A])(f: A => F[B])(implicit G: Traverse[G]): F[G[B]]
Inherited from
Applicative
def traverse1[A, G[_], B](value: G[A])(f: A => F[B])(implicit G: Traverse1[G]): F[G[B]]
Inherited from
Apply
def tuple2[A, B](fa: => F[A], fb: => F[B]): F[(A, B)]
Inherited from
Apply
def tuple3[A, B, C](fa: => F[A], fb: => F[B], fc: => F[C]): F[(A, B, C)]
Inherited from
Apply
def tuple4[A, B, C, D](fa: => F[A], fb: => F[B], fc: => F[C], fd: => F[D]): F[(A, B, C, D)]
Inherited from
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)]
Inherited from
Apply
def unfoldlPsum[S, A](seed: S)(f: S => Maybe[(S, F[A])]): F[A]
Inherited from
PlusEmpty
def unfoldlPsumOpt[S, A](seed: S)(f: S => Maybe[(S, F[A])]): Maybe[F[A]]
Inherited from
Plus
def unfoldrOpt[S, A, B](seed: S)(f: S => Maybe[(F[A], S)])(implicit R: Reducer[A, B]): Maybe[F[B]]
Inherited from
Apply
def unfoldrPsum[S, A](seed: S)(f: S => Maybe[(F[A], S)]): F[A]
Inherited from
PlusEmpty
def unfoldrPsumOpt[S, A](seed: S)(f: S => Maybe[(F[A], S)]): Maybe[F[A]]
Inherited from
Plus
def unite[T[_], A](value: F[T[A]])(implicit T: Foldable[T]): F[A]
Inherited from
MonadPlus
final def uniteU[T](value: F[T])(implicit T: Unapply[[F[_]] =>> Foldable[F], T]): F[A]
Inherited from
MonadPlus
def unlessM[A](cond: Boolean)(f: => F[A]): F[Unit]
Inherited from
Applicative
def untilM[G[_], A](f: F[A], cond: => F[Boolean])(implicit G: MonadPlus[G]): F[G[A]]
Inherited from
Monad
def untilM_[A](f: F[A], cond: => F[Boolean]): F[Unit]
Inherited from
Monad
def void[A](fa: F[A]): F[Unit]
Inherited from
Functor
def whenM[A](cond: Boolean)(f: => F[A]): F[Unit]
Inherited from
Applicative
def whileM[G[_], A](p: F[Boolean], body: => F[A])(implicit G: MonadPlus[G]): F[G[A]]
Inherited from
Monad
def whileM_[A](p: F[Boolean], body: => F[A]): F[Unit]
Inherited from
Monad
def widen[A, B](fa: F[A])(implicit ev: Liskov[A, B]): F[B]
Inherited from
Functor
final def xderiving0[Z](z: => Z): F[Z]
Inherited from
InvariantApplicative
final def xderiving1[Z, A1](f: A1 => Z, g: Z => A1)(implicit a1: F[A1]): F[Z]
Inherited from
InvariantApplicative
final def xderiving2[Z, A1, A2](f: (A1, A2) => Z, g: Z => (A1, A2))(implicit a1: F[A1], a2: F[A2]): F[Z]
Inherited from
InvariantApplicative
final def xderiving3[Z, A1, A2, A3](f: (A1, A2, A3) => Z, g: Z => (A1, A2, A3))(implicit a1: F[A1], a2: F[A2], a3: F[A3]): F[Z]
Inherited from
InvariantApplicative
final def xderiving4[Z, A1, A2, A3, A4](f: (A1, A2, A3, A4) => Z, g: Z => (A1, A2, A3, A4))(implicit a1: F[A1], a2: F[A2], a3: F[A3], a4: F[A4]): F[Z]
Inherited from
InvariantApplicative
def xmap[A, B](fa: F[A], f: A => B, g: B => A): F[B]
Inherited from
Functor
def xmapb[A, B](ma: F[A])(b: Bijection[A, B]): F[B]
Inherited from
InvariantFunctor
def xmapi[A, B](ma: F[A])(iso: IsoSet[A, B]): F[B]
Inherited from
InvariantFunctor
override def xproduct0[Z](z: => Z): F[Z]
Definition Classes
Applicative -> InvariantApplicative
Inherited from
Applicative
override def xproduct1[Z, A1](a1: => F[A1])(f: A1 => Z, g: Z => A1): F[Z]
Definition Classes
Applicative -> InvariantApplicative
Inherited from
Applicative
override def xproduct2[Z, A1, A2](a1: => F[A1], a2: => F[A2])(f: (A1, A2) => Z, g: Z => (A1, A2)): F[Z]
Definition Classes
Applicative -> InvariantApplicative
Inherited from
Applicative
override def xproduct3[Z, A1, A2, A3](a1: => F[A1], a2: => F[A2], a3: => F[A3])(f: (A1, A2, A3) => Z, g: Z => (A1, A2, A3)): F[Z]
Definition Classes
Applicative -> InvariantApplicative
Inherited from
Applicative
override def xproduct4[Z, A1, A2, A3, A4](a1: => F[A1], a2: => F[A2], a3: => F[A3], a4: => F[A4])(f: (A1, A2, A3, A4) => Z, g: Z => (A1, A2, A3, A4)): F[Z]
Definition Classes
Applicative -> InvariantApplicative
Inherited from
Applicative