monadic 0.5.5

macros to define Haskell style monadic action blocks for IntoIterators, Reader, Writer, State, and macros for the transformers ReaderT and WriterT over Vec, LinkedList and VecDeque
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! A Writer monad implementation

use crate::monoid::{Monoid};

//---------------------------------------------

#[derive(Clone)]  
pub struct Writer<A, W = String>{ 
  run_writer: (A, W)
  }

/*
#[derive(Clone)]  
pub struct WriterIterator<A> {
  traversed: bool,
  value: A,
}


impl<A: Clone> Iterator for WriterIterator<A> {
   type Item = A;
   
   fn next(&mut self) -> Option<A> {
     if self.traversed {None} 
     else {self.traversed = true;
           Some( self.value.clone())}
   }
}

impl<A: Clone, W> IntoIterator for  Writer<A, W> {
  type Item = A;
  type IntoIter = WriterIterator<A>; 
  
  fn into_iter(self) -> Self::IntoIter {
    
    WriterIterator{
      traversed: false,
      value: self.run_writer.0.clone()
    }
  }
}
*/

impl<A, W: Monoid, F> Writer<(A, F), W> 
    where F: Fn(W) -> W {

     fn pass(self) -> Writer<A, W> {
     
        let ((a, f), w) = self.run_writer;
        Writer{ run_writer: (a, f(w))}
     }
}


impl<A, W: Monoid + Clone> Writer<A, W> {

   pub fn bind<B, F>(self, f: F) -> Writer<B,W>
        where 
          F: Fn(A) -> Writer<B,W>,
          Self: Sized,
     {
        let (a, w) = self.run_writer;
        let (a1, mut w1) = f( a).run_writer ;
        Writer{ run_writer: (a1, w.mappend(&mut w1))}
     }

    pub fn pure(x: A) -> Self {
        Writer{ run_writer: (x, W::mempty())}
    }
    
    
    pub fn lift<B>(self, x: B) -> Writer<B, W> {
        Writer{ run_writer: (x, self.run_writer.1)}
    }

    pub fn unwrap_pair(self) -> (A, W) {
        self.run_writer
    }
    
    pub fn unwrap(self) -> A {
        self.run_writer.0
    }
  
    pub fn listen<>(self) -> Writer<(A, W), W> {
        let (a, w) = self.run_writer;
        Writer{ run_writer: ((a, (&w).clone()), w)}
    }

    pub fn listens<T, F: Fn(W) -> T>( self, f: F) -> Writer<(A, T), W> {
        let (a, w) = self.run_writer;
        Writer{ run_writer: ((a, f( (&w).clone())), w)}
    }
    
    pub fn censor<F: Fn(W) -> W>(self, f: F) -> Writer<A, W> {
        let (a, w) = self.run_writer;
        Writer{ run_writer: ((a,f), w)}.pass()
     }
}

pub fn tell<W: Clone>(s: W) -> Writer<(), W> {
        Writer{ run_writer: ((), s.clone())}
    }

pub fn tell_str(s: &str) -> Writer<(), String> {
        Writer{ run_writer: ((), String::from( s))}
    }

pub fn tell_array<T: Clone>(v: &[T]) -> Writer<(), Vec<T>> {
        Writer{ run_writer: ((), Vec::from( v))}
    }
    
pub fn censor<A, W: Monoid, F: Fn(W) -> W>(f: F, writer: Writer<A, W>) -> Writer<A, W> {
        let (a, w) = writer.run_writer;
        Writer{ run_writer: ((a,f), w)}.pass()
     }
     
pub fn listen<A, W: Clone>(writer: Writer<A, W>) -> Writer<(A, W), W> {
    let (a, w) = writer.run_writer;
    Writer{ run_writer: ((a, (&w).clone()), w)}
}

pub fn listens<A, W: Clone, T, F: Fn(W) -> T>( f: F, writer: Writer<A, W>) -> Writer<(A, T), W> {
    let (a, w) = writer.run_writer;
    Writer{ run_writer: ((a, f( (&w).clone())), w)}
}

    
/// macro for a `Writer<A, W = String>` monad that holds a pair (A, Monoid)
///
/// The logger type (a local *Monoid* instance) can be established by using a `tell_...()` generator
/// or by constraining the type of the macro result.
#[macro_export]
macro_rules! wrdo {
  (pure $e:expr                           ) => [Writer::pure($e)];
  (let $v:ident = $e:expr ; $($rest:tt)*) => [Writer::pure($e).bind( move |$v| { wrdo!($($rest)*)} )];
  (_ <- $monad:expr ; $($rest:tt)* ) => [Writer::bind( ($monad), move |_| { wrdo!($($rest)*)} )];
  ($v:ident <- pure $e:expr ; $($rest:tt)* ) => [Writer::bind( Writer::pure($e), move |$v| { wrdo!($($rest)*)} )];
  ($v:ident <- $monad:expr ; $($rest:tt)* ) => [Writer::bind( ($monad), move |$v| { wrdo!($($rest)*)} )];
  ($monad:expr                            ) => [$monad];
}