Package com.jnape.palatable.lambda.monad.transformer

Interface MonadT<M extends MonadRec<?,M>,A,MT extends MonadT<M,?,MT,T>,T extends MonadT<?,?,?,T>>

Type Parameters:
M - the argument monad
A - the carrier type
MT - the Monad witness
T - the MonadT witness
All Superinterfaces:
Applicative<A,MT>, Functor<A,MT>, Monad<A,MT>, MonadBase<M,A,T>, MonadRec<A,MT>
All Known Implementing Classes:
EitherT, IdentityT, IterateT, LazyT, MaybeT, ReaderT, SafeT, StateT, WriterT
public interface MonadT<M extends MonadRec<?,M>,A,MT extends MonadT<M,?,MT,T>,T extends MonadT<?,?,?,T>> extends MonadBase<M,A,T>, Monad<A,MT>, MonadRec<A,MT>
The generic type representing a Monad transformer, exposing the argument Monad as a type parameter.

While any two functors and any two applicatives can be composed in general, the same is not true in general of any two monads. However, there exist monads that do compose, in general, with any other Monad. When this is the case, the combination of these monads with any other Monad can offer composed implementations of pure and flatMap for free, simply by relying on the other monad's implementation of both, as well as their own privileged knowledge about how to merge the nested flatMap call. This can be thought of as "gluing" together two monads, allowing easier access to their values, as well as, in some cases, providing universally correct constructions of the composed short-circuiting algorithms.

The term "monad transformer" describes this particular encoding of monadic composition, and tends to be named in terms of Monad for which privileged knowledge must be known in order to eliminate during flatmapping.

For more information, read more about monad transformers.

See Also:

  • Method Summary

    Modifier and Type
    Method
    Description
    default <B> MonadT<M,B,MT,T>
    discardL(Applicative<B,MT> appB)
    Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.
    default <B> MonadT<M,A,MT,T>
    discardR(Applicative<B,MT> appB)
    Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.
    <B> MonadT<M,B,MT,T>
    flatMap(Fn1<? super A,? extends Monad<B,MT>> f)
    Chain dependent computations that may continue or short-circuit based on previous results.
    default <B> MonadT<M,B,MT,T>
    fmap(Fn1<? super A,? extends B> fn)
    Covariantly transmute this functor's parameter using the given mapping function.
    default <B> Lazy<? extends MonadT<M,B,MT,T>>
    lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MT>> lazyAppFn)
    Given a lazy instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
    <B, N extends MonadRec<?, N>>
    MonadT<N,B,?,T>
    lift(MonadRec<B,N> mb)
    Lift a new argument MonadRec into this MonadBase.
    <B> MonadT<M,B,MT,T>
    pure(B b)
    Lift the value b into this applicative functor.
    default <B> MonadT<M,B,MT,T>
    zip(Applicative<Fn1<? super A,? extends B>,MT> appFn)
    Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.

    Methods inherited from interface com.jnape.palatable.lambda.functor.Functor

    coerce

    Methods inherited from interface com.jnape.palatable.lambda.monad.MonadRec

    trampolineM

  • Method Details

    • lift

      <B, N extends MonadRec<?, N>> MonadT<N,B,?,T> lift(MonadRec<B,N> mb)
      Lift a new argument MonadRec into this MonadBase.
      Specified by:
      lift in interface MonadBase<M extends MonadRec<?,M>,A,MT extends MonadT<M,?,MT,T>>
      Type Parameters:
      B - the MonadRec carrier type
      N - the argument MonadRec witness
      Parameters:
      mb - the argument MonadRec
      Returns:
      the new MonadBase

    • flatMap

      <B> MonadT<M,B,MT,T> flatMap(Fn1<? super A,? extends Monad<B,MT>> f)
      Chain dependent computations that may continue or short-circuit based on previous results.
      Specified by:
      flatMap in interface Monad<M extends MonadRec<?,M>,A>
      Specified by:
      flatMap in interface MonadRec<M extends MonadRec<?,M>,A>
      Type Parameters:
      B - the resulting monad parameter type
      Parameters:
      f - the dependent computation over A
      Returns:
      the new monad instance

    • pure

      <B> MonadT<M,B,MT,T> pure(B b)
      Lift the value b into this applicative functor.
      Specified by:
      pure in interface Applicative<M extends MonadRec<?,M>,A>
      Specified by:
      pure in interface Monad<M extends MonadRec<?,M>,A>
      Specified by:
      pure in interface MonadRec<M extends MonadRec<?,M>,A>
      Type Parameters:
      B - the type of the returned applicative's parameter
      Parameters:
      b - the value
      Returns:
      an instance of this applicative over b

    • fmap

      default <B> MonadT<M,B,MT,T> fmap(Fn1<? super A,? extends B> fn)
      Covariantly transmute this functor's parameter using the given mapping function. Generally this method is specialized to return an instance of the class implementing Functor.
      Specified by:
      fmap in interface Applicative<M extends MonadRec<?,M>,A>
      Specified by:
      fmap in interface Functor<M extends MonadRec<?,M>,A>
      Specified by:
      fmap in interface Monad<M extends MonadRec<?,M>,A>
      Specified by:
      fmap in interface MonadRec<M extends MonadRec<?,M>,A>
      Type Parameters:
      B - the new parameter type
      Parameters:
      fn - the mapping function
      Returns:
      a functor over B (the new parameter type)

    • zip

      default <B> MonadT<M,B,MT,T> zip(Applicative<Fn1<? super A,? extends B>,MT> appFn)
      Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.
      Specified by:
      zip in interface Applicative<M extends MonadRec<?,M>,A>
      Specified by:
      zip in interface Monad<M extends MonadRec<?,M>,A>
      Specified by:
      zip in interface MonadRec<M extends MonadRec<?,M>,A>
      Type Parameters:
      B - the resulting applicative parameter type
      Parameters:
      appFn - the other applicative instance
      Returns:
      the mapped applicative

    • lazyZip

      default <B> Lazy<? extends MonadT<M,B,MT,T>> lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,MT>> lazyAppFn)
      Given a lazy instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports. This is useful for applicatives that support lazy evaluation and early termination.
      Specified by:
      lazyZip in interface Applicative<M extends MonadRec<?,M>,A>
      Specified by:
      lazyZip in interface Monad<M extends MonadRec<?,M>,A>
      Specified by:
      lazyZip in interface MonadRec<M extends MonadRec<?,M>,A>
      Type Parameters:
      B - the resulting applicative parameter type
      Parameters:
      lazyAppFn - the lazy other applicative instance
      Returns:
      the mapped applicative
      See Also:

    • discardL

      default <B> MonadT<M,B,MT,T> discardL(Applicative<B,MT> appB)
      Sequence both this Applicative and appB, discarding this Applicative's result and returning appB. This is generally useful for sequentially performing side-effects.
      Specified by:
      discardL in interface Applicative<M extends MonadRec<?,M>,A>
      Specified by:
      discardL in interface Monad<M extends MonadRec<?,M>,A>
      Specified by:
      discardL in interface MonadRec<M extends MonadRec<?,M>,A>
      Type Parameters:
      B - the type of the returned Applicative's parameter
      Parameters:
      appB - the other Applicative
      Returns:
      appB

    • discardR

      default <B> MonadT<M,A,MT,T> discardR(Applicative<B,MT> appB)
      Sequence both this Applicative and appB, discarding appB's result and returning this Applicative. This is generally useful for sequentially performing side-effects.
      Specified by:
      discardR in interface Applicative<M extends MonadRec<?,M>,A>
      Specified by:
      discardR in interface Monad<M extends MonadRec<?,M>,A>
      Specified by:
      discardR in interface MonadRec<M extends MonadRec<?,M>,A>
      Type Parameters:
      B - the type of appB's parameter
      Parameters:
      appB - the other Applicative
      Returns:
      this Applicative