Struct Writer 

pub struct Writer<A, W: Monoid> { /* private fields */ }

Writer helps capture the pattern of writing to a pure log or accumulated value, handling the book-keeping for you. This is often used for loggers, but could be anything as long as the hidden value is a Monoid.

There are many applications of Writers, but as an illustrative point, one could use it for logging across processes and time, since the log is carried around with the result in a pure fashion. The monadic DSL helps make using these feel more natural.

Implementations

impl<A, W: Monoid> Writer<A, W>

pub fn new(value: A, log: W) -> Self

Construct a Writer struct from a starting value and log.

Examples found in repository

examples/turtle/model/helpers.rs (lines 14-17)

pub fn lift_op<'a, A: 'a>(
    op_fun: impl Fn(Turtle, A) -> Turtle + 'static,
) -> impl FnOnce(A) -> StateT<'a, Turtle, ResultT<Writer<Result<((), Turtle), TurtleError>, String>>>
{
    move |p: A| {
        StateT::new(move |s| {
            ResultT::lift(Writer::new(
                ((), op_fun(s, p)),
                <String as Monoid>::mempty(),
            ))
        })
    }
}

pub fn lift_validation<'a, A: 'a>(
    validate_fun: impl Fn(String) -> Result<A, TurtleError>,
) -> impl Fn(&str) -> StateT<'a, Turtle, ResultT<Writer<Result<(A, Turtle), TurtleError>, String>>>
{
    move |p: &str| {
        StateT::<'a, Turtle, ResultT<Writer<Result<(A, Turtle), TurtleError>, String>>>::lift(
            ResultT::new(Writer::new(
                validate_fun(p.to_string()),
                <String as Monoid>::mempty(),
            )),
        )
    }
}

pub fn tell(log: W) -> Writer<(), W>

Construct a Writer struct from a log.

Examples found in repository

examples/turtle/model/helpers.rs (line 40)

pub fn log_info(
    l: String,
) -> StateT<'static, Turtle, ResultT<Writer<Result<((), Turtle), TurtleError>, String>>> {
    StateT::<Turtle, ResultT<Writer<Result<(), TurtleError>, String>>>::lift(ResultT::lift(
        Writer::<Turtle, _>::tell(String::from(l)),
    ))
}

pub fn execute(self) -> (A, W)

Extract the enclosed value and log from an Writer.

Examples found in repository

examples/turtle/model/helpers.rs (line 87)

pub fn run(
    computation: StateT<Turtle, ResultT<Writer<Result<((), Turtle), TurtleError>, String>>>,
    t: Turtle,
) -> (Result<((), Turtle), TurtleError>, String) {
    Writer::execute(ResultT::execute(StateT::execute(computation, t)))
}

Trait Implementations

impl<'a, A: 'a, W: Monoid> Applicative<'a> for Writer<A, W>

fn of(value: Self::Unwrapped) -> Self::Wrapped<Self::Unwrapped>

Lift a value into a context

impl<'a, A, W: Monoid> Apply<'a> for Writer<A, W>

fn ap<F, B: 'a>(self, f: Self::Wrapped<F>) -> Self::Wrapped<B>

where F: FnOnce(Self::Unwrapped) -> B + 'a,

Apply a function wrapped in a context to to a value wrapped in the same type of context

fn lift_a2<F, B: 'a, C: 'a>(self, b: Self::Wrapped<B>, f: F) -> Self::Wrapped<C>

where F: FnOnce(Self::Unwrapped, B) -> C,

Lift an (unwrapped) binary function and apply to two wrapped values

impl<'a, A, W: Monoid> Functor<'a> for Writer<A, W>

type Unwrapped = A

The inner type which will be mapped over

type Wrapped<B: 'a> = Writer<B, W>

Target of the fmap operation. Like Self, but has a different wrapped up value underneath.

fn fmap<F, B: 'a>(self, f: F) -> Self::Wrapped<B>

where F: FnOnce(Self::Unwrapped) -> B,

fmap is used to apply a function of type (a -> b) to a value of type f a, where f is a functor, to produce a value of type f b.

impl<'a, A: 'a, W: Monoid> Monad<'a> for Writer<A, W>

type Unwrapped = A

type Wrapped<B: 'a> = Writer<B, W>

fn bind<F, B: 'a>(self, f: F) -> Self::Wrapped<B>

where F: FnOnce(Self::Unwrapped) -> Self::Wrapped<B> + 'a,

Sequentially compose actions, piping values through successive function chains.

fn of<T: 'a>(value: T) -> Self::Wrapped<T>

Lift a value into a context