1
public class Writer<T, TContent>
2
{
3
    private readonly Lazy<Tuple<T, TContent>> lazy;
4

5
    public Writer(Func<Tuple<T, TContent>> factory, IMonoid<TContent> monoid)
6
    {
7
        this.lazy = new Lazy<Tuple<T, TContent>>(factory);
8
        this.Monoid = monoid;
9
    }
10

11
    public T Value
12
    {
13
        [Pure]get { return this.lazy.Value.Item1; }
14
    }
15
public TContent Content
16
    {
17
        [Pure]get { return this.lazy.Value.Item2; }
18
    }
19

20
    public IMonoid<TContent> Monoid {[Pure] get; }
21
}

1
[Pure]
2
public static partial class WriterExtensions
3
{
4
    // Required by LINQ.
5
    public static Writer<TResult, TContent> SelectMany<TSource, TContent, TSelector, TResult>
6
        (this Writer<TSource, TContent> source,
7
         Func<TSource, Writer<TSelector, TContent>> selector,
8
         Func<TSource, TSelector, TResult> resultSelector) =>
9
            new Writer<TResult, TContent>(() =>
10
                {
11
                    Writer<TSelector, TContent> selectorResult = selector(source.Value);
12
                    return Tuple.Create(
13
                        resultSelector(source.Value, selectorResult.Value),
14
                        source.Monoid.Binary(source.Content, selectorResult.Content));
15
                }, source.Monoid);
16

17
    // Not required, just for convenience.
18
    public static Writer<TResult, TContent> SelectMany<TSource, TContent, TResult>
19
        (this Writer<TSource, TContent> source,
20
            Func<TSource, Writer<TResult, TContent>> selector) => source.SelectMany(selector, Functions.False);
21
}

1
// [Pure]
2
public static partial class WriterExtensions
3
{
4
    // μ: Writer<Writer<T, TContent>> => Writer<T, TContent>
5
    public static Writer<TResult, TContent> Flatten<TResult, TContent>
6
        (Writer<Writer<TResult, TContent>, TContent> source) => source.SelectMany(Functions.Id);
7

8
    // η: T -> Writer<T, TContent>
9
    public static Writer<T, TContent> Writer<T, TContent>
10
        (this T value, TContent content, IMonoid<TContent> monoid) =>
11
            new Writer<T, TContent>(() => Tuple.Create(value, content), monoid);
12

13
    // φ: Lazy<Writer<T1, TContent>, Writer<T2, TContent>> => Writer<Lazy<T1, T2>, TContent>
14
    public static Writer<Lazy<T1, T2>, TContent> Binary<T1, T2, TContent>
15
        (this Lazy<Writer<T1, TContent>, Writer<T2, TContent>> binaryFunctor) =>
16
            binaryFunctor.Value1.SelectMany(
17
                value1 => binaryFunctor.Value2,
18
                (value1, value2) => new Lazy<T1, T2>(value1, value2));
19

20
    // ι: TUnit -> Writer<TUnit, TContent>
21
    public static Writer<Unit, TContent> Unit<TContent>
22
        (Unit unit, TContent content, IMonoid<TContent> monoid) => unit.Writer(content, monoid);
23

24
    // Select: (TSource -> TResult) -> (Writer<TSource, TContent> -> Writer<TResult, TContent>)
25
    public static Writer<TResult, TContent> Select<TSource, TResult, TContent>
26
        (this Writer<TSource, TContent> source, Func<TSource, TResult> selector) =>
27
            source.SelectMany(value => selector(value).Writer(source.Content, source.Monoid));
28
}

1
// [Pure]
2
public static partial class WriterExtensions
3
{
4
    public static Writer<TSource, IEnumerable<string>> WithLog<TSource>(this TSource value, string log) =>
5
        value.Writer(
6
            $"{DateTime.Now.ToString("o", CultureInfo.InvariantCulture)} - {log}".Enumerable(),
7
            Enumerable.Empty<string>().Monoid((a, b) => a.Concat(b)));
8
}

1
public static void Stack()
2
{
3
    IEnumerable<int> stack = Enumerable.Empty<int>();
4
    Writer<IEnumerable<int>, IEnumerable<string>> writer =
5
        from lazy1 in stack.Push(1).WithLog("Push 1 to stack.")
6
        from lazy2 in lazy1.Value2.Push(2).WithLog("Push 2 to stack.")
7
        from lazy3 in lazy2.Value2.Pop().WithLog("Pop 2 from stack.")
8
        from stack1 in Enumerable.Range(0, 3).WithLog("Reset stack to 0, 1, 2.")
9
        from lazy4 in stack1.Push(4).WithLog("Push 4 to stack.")
10
        from lazy5 in lazy4.Value2.Pop().WithLog("Pop 4 from stack.")
11
        from stack2 in lazy5.Value2.WithLog("Get current stack.")
12
        select stack2;
13

14
    IEnumerable<int> resultStack = writer.Value;
15
    IEnumerable<string> logs = writer.Content;
16
    logs.ForEach(log => Trace.WriteLine(log));
17
}

1
public partial class MonadTests
2
{
3
    [TestMethod()]
4
    public void WriterTest()
5
    {
6
        bool isExecuted1 = false;
7
        Func<int> f1 = () => 1;
8
        Func<int, Func<int, Func<string, int>>> f2 = x => y => z =>
9
            { isExecuted1 = true; return x + y + z.Length; };
10
        Writer<int, IEnumerable<string>> query = from x in f1().WithLog("a")
11
                                                    from y in 2.WithLog("b")
12
                                                    from z in "xyz".WithLog("c")
13
                                                    select f2(x)(y)(z);
14
        Assert.IsFalse(isExecuted1); // Laziness.
15
        Assert.AreEqual(1 + 2 + "xyz".Length, query.Value); // Execution.
16
        string[] logs = query.Content.ToArray();
17
        Assert.IsTrue(logs.Length==3);
18
        Assert.IsTrue(logs[0].EndsWith(" - a"));
19
        Assert.IsTrue(logs[1].EndsWith(" - b"));
20
        Assert.IsTrue(logs[2].EndsWith(" - c"));
21
        Assert.IsTrue(isExecuted1);
22

23
        IMonoid<string> monoid = string.Empty.Monoid((a, b) => string.Concat(a, b));
24
        // Monad law 1: m.Monad().SelectMany(f) == f(m)
25
        Func<int, Writer<int, string>> addOne = x => (x + 1).Writer("a", monoid);
26
        Writer<int, string> left = 1.Writer("b", monoid).SelectMany(addOne);
27
        Writer<int, string> right = addOne(1);
28
        Assert.AreEqual(left.Value, right.Value);
29
        Assert.AreEqual("ba", left.Content);
30
        Assert.AreEqual("a", right.Content);
31
        // Monad law 2: M.SelectMany(Monad) == M
32
        Func<int, Writer<int, string>> Resturn = x => x.Writer("abc", monoid);
33
        Writer<int, string> M = Resturn(1);
34
        left = M.SelectMany(Resturn);
35
        right = M;
36
        Assert.AreEqual(left.Value, right.Value);
37
        Assert.AreEqual("abcabc", left.Content);
38
        Assert.AreEqual("abc", right.Content);
39
        // Monad law 3: M.SelectMany(f1).SelectMany(f2) == M.SelectMany(x => f1(x).SelectMany(f2))
40
        Func<int, Writer<int, string>> addTwo = x => (x + 2).Writer("b", monoid);
41
        left = M.SelectMany(addOne).SelectMany(addTwo);
42
        right = M.SelectMany(x => addOne(x).SelectMany(addTwo));
43
        Assert.AreEqual(left.Value, right.Value);
44
        Assert.AreEqual("abcab", left.Content);
45
        Assert.AreEqual("abcab", right.Content);
46
    }
47
}