Struct WriterT 

pub struct WriterT<W, MKind: Kind1, A> {
    pub run_writer_t: MKind::Of<(A, W)>,
    /* private fields */
}

The WriterT monad transformer for Kind-encoded types.

WriterT<W, MKind, A> wraps an inner value MKind::Of<(A, W)>: the produced value A paired with an accumulated monoidal log W. The value is stored in run_writer_t.

Type Parameters

• W: the log type (must be a Monoid for the Applicative/Monad instances).
• MKind: the Kind marker for the inner monad (must implement Kind1).
• A: the value produced alongside the log.

Fields

run_writer_t: MKind::Of<(A, W)>

The wrapped inner computation: MKind::Of<(A, W)> (value-then-log).

Implementations

impl<W, MKind: Kind1, A> WriterT<W, MKind, A>

pub fn new(inner: MKind::Of<(A, W)>) -> Self

Creates a new WriterT from an inner value MKind::Of<(A, W)>.

impl<W, MKind: Kind1, A> WriterT<W, MKind, A>

pub fn eval_writer_t(self) -> MKind::Of<A>

where W: 'static, A: 'static, MKind: Functor<(A, W), A> + 'static, MKind::Of<(A, W)>: 'static,

Runs the computation and keeps only the produced value, discarding the log: MKind::Of<A> (inner Functor, projecting fst).

pub fn exec_writer_t(self) -> MKind::Of<W>

where W: 'static, A: 'static, MKind: Functor<(A, W), W> + 'static, MKind::Of<(A, W)>: 'static,

Runs the computation and keeps only the accumulated log, discarding the value: MKind::Of<W> (inner Functor, projecting snd).

pub fn listen(self) -> WriterT<W, MKind, (A, W)>

where W: Clone + 'static, A: 'static, MKind: Functor<(A, W), ((A, W), W)> + 'static, MKind::Of<(A, W)>: 'static, MKind::Of<((A, W), W)>: 'static,

Exposes the accumulated log alongside the value, leaving it in place — the chainable method form of <WriterTKind<W, MKind> as MonadWriter<W, A, MKind>>::listen(self).

The produced value becomes (A, W) and the log remains W.

Example

use monadify::transformers::writer::{Writer, WriterTKind, MonadWriter};
use monadify::identity::{Identity, IdentityKind};

let w: Writer<String, ()> =
    WriterTKind::<String, IdentityKind>::tell("xyz".to_string());
let Identity((((), exposed), log)) = w.listen().run_writer_t;
assert_eq!(exposed, "xyz");
assert_eq!(log, "xyz");

pub fn censor<F>(self, f: F) -> Self

where W: 'static, A: 'static, MKind: Functor<(A, W), (A, W)> + 'static, MKind::Of<(A, W)>: 'static, F: Fn(W) -> W + Clone + 'static,

Rewrites the log with f, leaving the value unchanged — the chainable method form of <WriterTKind<W, MKind> as MonadWriter<W, A, MKind>>::censor(f, self).

The result is (a, f(w)).

Example

use monadify::transformers::writer::{Writer, WriterTKind, MonadWriter};
use monadify::identity::{Identity, IdentityKind};

let w: Writer<String, ()> =
    WriterTKind::<String, IdentityKind>::tell("quiet".to_string());
let Identity(((), log)) = w.censor(|s: String| s.to_uppercase()).run_writer_t;
assert_eq!(log, "QUIET");

Trait Implementations

impl<W, MKind: Kind1, A> Clone for WriterT<W, MKind, A>

where MKind::Of<(A, W)>: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.