com.jnape.palatable.lambda.functor.builtin.Writer<W,A>

Type Parameters:: W - the accumulation type; A - the value type

All Implemented Interfaces:: Applicative<A, Writer<W,?>>, Functor<A, Writer<W,?>>, Monad<A, Writer<W,?>>, MonadRec<A, Writer<W,?>>, MonadWriter<W, A, Writer<W,?>>

public final class Writer<W,A> extends Object implements MonadWriter<W, A, Writer<W,?>>, MonadRec<A, Writer<W,?>>

The lazy writer monad, a monad capturing some accumulation (eventually to be folded in terms of a given monoid) and a value. Note that unlike the State monad, the Writer monad does not allow the value to be fully derived from the accumulation.

Field Summary

Fields

Modifier and Type

Field

Description

private final Fn1<? super Monoid<W>, ? extends Tuple2<A,W>>

writerFn
Constructor Summary

Constructors

Modifier

Constructor

Description

private

Writer(Fn1<? super Monoid<W>, ? extends Tuple2<A,W>> writerFn)
Method Summary

Modifier and Type

Method

Description

Writer<W,A>

censor(Fn1<? super W, ? extends W> fn)

Update the accumulated state.

 Writer<W,B>

discardL(Applicative<B, Writer<W,?>> appB)

Sequence both this Applicative and appB, discarding this Applicative's result and returning appB.

 Writer<W,A>

discardR(Applicative<B, Writer<W,?>> appB)

Sequence both this Applicative and appB, discarding appB's result and returning this Applicative.

 Writer<W,B>

flatMap(Fn1<? super A, ? extends Monad<B, Writer<W,?>>> f)

Chain dependent computations that may continue or short-circuit based on previous results.

 Writer<W,B>

fmap(Fn1<? super A, ? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function.

 Lazy<Writer<W,B>>

lazyZip(Lazy<? extends Applicative<Fn1<? super A, ? extends B>, Writer<W,?>>> 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.

static <W,A> Writer<W,A>

listen(A a)

Construct a Writer from a value.

 Writer<W, Tuple2<A,B>>

listens(Fn1<? super W, ? extends B> fn)

Map the accumulation into a value and pair it with the current output.

 Writer<W,B>

pure(B b)

Lift the value b into this applicative functor.

static <W> Pure<Writer<W,?>>

pureWriter()

The canonical Pure instance for Writer.

Tuple2<A,W>

runWriter(Monoid<W> monoid)

Given a Monoid for the accumulation, run the computation represented by this Writer, accumulate the written output in terms of the Monoid, and produce the accumulation and the value.

static <W> Writer<W,Unit>

tell(W w)

Construct a Writer from an accumulation.

 Writer<W,B>

trampolineM(Fn1<? super A, ? extends MonadRec<RecursiveResult<A,B>, Writer<W,?>>> fn)

Given some operation yielding a RecursiveResult inside this MonadRec, internally trampoline the operation until it yields a termination instruction.

static <W,A> Writer<W,A>

writer(Tuple2<A,W> aw)

Construct a Writer from an accumulation and a value.

 Writer<W,B>

zip(Applicative<Fn1<? super A, ? extends B>, Writer<W,?>> 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 class Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface Functor
coerce

Field Details
- writerFn
 
 private final Fn1<? super Monoid<W>, ? extends Tuple2<A,W>> writerFn
Constructor Details
- Writer
 
 private Writer(Fn1<? super Monoid<W>, ? extends Tuple2<A,W>> writerFn)
Method Details
- runWriter
 
 public Tuple2<A,W> runWriter(Monoid<W> monoid)
 
 Given a Monoid for the accumulation, run the computation represented by this Writer, accumulate the written output in terms of the Monoid, and produce the accumulation and the value.
 
 Parameters:
 
 monoid - the accumulation Monoid
 
 Returns:
 
 the accumulation with the value
- listens
 
 public Writer<W, Tuple2<A,B>> listens(Fn1<? super W, ? extends B> fn)
 
 Map the accumulation into a value and pair it with the current output.
 
 Specified by:
 
 listens in interface MonadWriter<W, A, Writer<W,?>>
 
 Type Parameters:
 
 B - the mapped output
 
 Parameters:
 
 fn - the mapping function
 
 Returns:
 
 the updated MonadWriter
- censor
 
 public Writer<W,A> censor(Fn1<? super W, ? extends W> fn)
 
 Update the accumulated state.
 
 Specified by:
 
 censor in interface MonadWriter<W, A, Writer<W,?>>
 
 Parameters:
 
 fn - the update function
 
 Returns:
 
 the updated MonadWriter
- trampolineM
 public Writer<W,B> trampolineM(Fn1<? super A, ? extends MonadRec<RecursiveResult<A,B>, Writer<W,?>>> fn)
 
 Given some operation yielding a RecursiveResult inside this MonadRec, internally trampoline the operation until it yields a termination instruction.
 Stack-safety depends on implementations guaranteeing that the growth of the call stack is a constant factor independent of the number of invocations of the operation. For various examples of how this can be achieved in stereotypical circumstances, see the referenced types.
 
 Specified by:
 
 trampolineM in interface MonadRec<W,A>
 
 Type Parameters:
 
 B - the ultimate resulting carrier type
 
 Parameters:
 
 fn - the function to internally trampoline
 
 Returns:
 
 the trampolined MonadRec
 
 See Also:
 
 for a basic implementation
 
 for a coproduct implementation
 
 for an implementation leveraging an already stack-safe Monad#flatMap(Fn1)
 
 for a monad transformer implementation
- flatMap
 
 public Writer<W,B> flatMap(Fn1<? super A, ? extends Monad<B, Writer<W,?>>> f)
 
 Chain dependent computations that may continue or short-circuit based on previous results.
 
 Specified by:
 
 flatMap in interface Monad<W,A>
 
 Specified by:
 
 flatMap in interface MonadRec<W,A>
 
 Specified by:
 
 flatMap in interface MonadWriter<W, A, Writer<W,?>>
 
 Type Parameters:
 
 B - the resulting monad parameter type
 
 Parameters:
 
 f - the dependent computation over A
 
 Returns:
 
 the new monad instance
- pure
 
 public Writer<W,B> pure(B b)
 
 Lift the value b into this applicative functor.
 
 Specified by:
 
 pure in interface Applicative<W,A>
 
 Specified by:
 
 pure in interface Monad<W,A>
 
 Specified by:
 
 pure in interface MonadRec<W,A>
 
 Specified by:
 
 pure in interface MonadWriter<W, A, Writer<W,?>>
 
 Type Parameters:
 
 B - the type of the returned applicative's parameter
 
 Parameters:
 
 b - the value
 
 Returns:
 
 an instance of this applicative over b
- fmap
 
 public Writer<W,B> 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<W,A>
 
 Specified by:
 
 fmap in interface Functor<W,A>
 
 Specified by:
 
 fmap in interface Monad<W,A>
 
 Specified by:
 
 fmap in interface MonadRec<W,A>
 
 Specified by:
 
 fmap in interface MonadWriter<W, A, Writer<W,?>>
 
 Type Parameters:
 
 B - the new parameter type
 
 Parameters:
 
 fn - the mapping function
 
 Returns:
 
 a functor over B (the new parameter type)
- zip
 
 public Writer<W,B> zip(Applicative<Fn1<? super A, ? extends B>, Writer<W,?>> 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<W,A>
 
 Specified by:
 
 zip in interface Monad<W,A>
 
 Specified by:
 
 zip in interface MonadRec<W,A>
 
 Specified by:
 
 zip in interface MonadWriter<W, A, Writer<W,?>>
 
 Type Parameters:
 
 B - the resulting applicative parameter type
 
 Parameters:
 
 appFn - the other applicative instance
 
 Returns:
 
 the mapped applicative
- lazyZip
 public Lazy<Writer<W,B>> lazyZip(Lazy<? extends Applicative<Fn1<? super A, ? extends B>, Writer<W,?>>> 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<W,A>
 
 Specified by:
 
 lazyZip in interface Monad<W,A>
 
 Specified by:
 
 lazyZip in interface MonadRec<W,A>
 
 Specified by:
 
 lazyZip in interface MonadWriter<W, A, Writer<W,?>>
 
 Type Parameters:
 
 B - the resulting applicative parameter type
 
 Parameters:
 
 lazyAppFn - the lazy other applicative instance
 
 Returns:
 
 the mapped applicative
 
 See Also:
 
 Maybe
 
 Either
- discardL
 
 public Writer<W,B> discardL(Applicative<B, Writer<W,?>> 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<W,A>
 
 Specified by:
 
 discardL in interface Monad<W,A>
 
 Specified by:
 
 discardL in interface MonadRec<W,A>
 
 Specified by:
 
 discardL in interface MonadWriter<W, A, Writer<W,?>>
 
 Type Parameters:
 
 B - the type of the returned Applicative's parameter
 
 Parameters:
 
 appB - the other Applicative
 
 Returns:
 
 appB
- discardR
 
 public Writer<W,A> discardR(Applicative<B, Writer<W,?>> 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<W,A>
 
 Specified by:
 
 discardR in interface Monad<W,A>
 
 Specified by:
 
 discardR in interface MonadRec<W,A>
 
 Specified by:
 
 discardR in interface MonadWriter<W, A, Writer<W,?>>
 
 Type Parameters:
 
 B - the type of appB's parameter
 
 Parameters:
 
 appB - the other Applicative
 
 Returns:
 
 this Applicative
- tell
 
 public static <W> Writer<W,Unit> tell(W w)
 
 Construct a Writer from an accumulation.
 
 Type Parameters:
 
 W - the accumulation type
 
 Parameters:
 
 w - the accumulation
 
 Returns:
 
 the Writer
- listen
 
 public static <W,A> Writer<W,A> listen(A a)
 
 Construct a Writer from a value.
 
 Type Parameters:
 
 W - the accumulation type
 
 A - the value type
 
 Parameters:
 
 a - the output value
 
 Returns:
 
 the Writer
- writer
 
 public static <W,A> Writer<W,A> writer(Tuple2<A,W> aw)
 
 Construct a Writer from an accumulation and a value.
 
 Type Parameters:
 
 W - the accumulation type
 
 A - the value type
 
 Parameters:
 
 aw - the output value and accumulation
 
 Returns:
 
 the WriterT
- pureWriter
 
 public static <W> Pure<Writer<W,?>> pureWriter()
 
 The canonical Pure instance for Writer.
 
 Type Parameters:
 
 W - the accumulation type
 
 Returns:
 
 the Pure instance

Class Writer<W,A>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class Object

Methods inherited from interface Functor

Field Details

writerFn

Constructor Details

Writer

Method Details

runWriter

listens

censor

trampolineM

flatMap

pure

fmap

zip

lazyZip

discardL

discardR

tell

listen

writer

pureWriter