1
// Reader<TEnvironment, T> is alias of Func<TEnvironment, T>
2
public delegate T Reader<in TEnvironment, out T>(TEnvironment environment);

1
[Pure]
2
public static partial class ReaderExtensions
3
{
4
    // Required by LINQ.
5
    public static Reader<TEnvironment, TResult> SelectMany<TEnvironment, TSource, TSelector, TResult>
6
        (this Reader<TEnvironment, TSource> source,
7
         Func<TSource, Reader<TEnvironment, TSelector>> selector,
8
         Func<TSource, TSelector, TResult> resultSelector) =>
9
            environment =>
10
                {
11
                    TSource sourceResult = source(environment);
12
                    return resultSelector(sourceResult, selector(sourceResult)(environment));
13
                };
14

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

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

8
    // η: T -> Reader<TEnvironment, T>
9
    public static Reader<TEnvironment, T> Reader<TEnvironment, T>
10
        (this T value) => environment => value;
11

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

19
    // ι: TUnit -> Reader<TEnvironment, TUnit>
20
    public static Reader<TEnvironment, Unit> Unit<TEnvironment>
21
        (Unit unit) => unit.Reader<TEnvironment, Unit>();
22

23
    // Select: (TSource -> TResult) -> (Reader<TEnvironment, TSource> -> Reader<TEnvironment, TResult>)
24
    public static Reader<TEnvironment, TResult> Select<TEnvironment, TSource, TResult>
25
        (this Reader<TEnvironment, TSource> source, Func<TSource, TResult> selector) =>
26
            source.SelectMany(value => selector(value).Reader<TEnvironment, TResult>());
27
}

1
Reader<Settings, string> query =
2
    // 1. Use settings.
3
    from html in new Reader<Settings, string>(settings => DownloadString(settings.BlogUrl))
4
    // 2. Use settings.
5
    from _ in new Reader<Settings, Unit>(settings => SaveToDatabase(settings.ConnectionString, html))
6
    // 3. Update settings.
7
    from __ in new Reader<Settings, Settings>(settings => UpdateSettings(settings))
8
    // 4. Use settings. Here settings are updated.
9
    from ___ in new Reader<Settings, Unit>(settings => ListenToPort(settings.Port))
10
    select html;
11
string result = query(Settings.Default);

1
public partial class MonadTests
2
{
3
    [TestMethod()]
4
    public void ReaderTest()
5
    {
6
        bool isExecuted1 = false;
7
        bool isExecuted2 = false;
8
        bool isExecuted3 = false;
9
        bool isExecuted4 = false;
10
        Reader<int, int> f1 = x => { isExecuted1 = true; return x + 1; };
11
        Reader<int, string> f2 = x =>
12
            { isExecuted2 = true; return x.ToString(CultureInfo.InvariantCulture); };
13
        Func<string, Reader<int, int>> f3 = x => y => { isExecuted3 = true; return x.Length + y; };
14
        Func<int, Func<int, int>> f4 = x => y => { isExecuted4 = true; return x + y; };
15
        Reader<int, int> query1 = from x in f1
16
                                    from y in f2
17
                                    from z in f3(y)
18
                                    from _ in f1
19
                                    let f4x = f4(x)
20
                                    select f4x(z);
21
        Assert.IsFalse(isExecuted1); // Laziness.
22
        Assert.IsFalse(isExecuted2); // Laziness.
23
        Assert.IsFalse(isExecuted3); // Laziness.
24
        Assert.IsFalse(isExecuted4); // Laziness.
25
        Assert.AreEqual(1 + 1 + 1 + 1, query1(1)); // Execution.
26
        Assert.IsTrue(isExecuted1);
27
        Assert.IsTrue(isExecuted2);
28
        Assert.IsTrue(isExecuted3);
29
        Assert.IsTrue(isExecuted4);
30

31
        Tuple<bool, string> config = Tuple.Create(true, "abc");
32
        // Monad law 1: m.Monad().SelectMany(f) == f(m)
33
        Func<int, Reader<Tuple<bool, string>, int>> addOne = x => c => x + 1;
34
        Reader<Tuple<bool, string>, int> left = 1.Reader<Tuple<bool, string>, int>().SelectMany(addOne);
35
        Reader<Tuple<bool, string>, int> right = addOne(1);
36
        Assert.AreEqual(left(config), right(config));
37
        // Monad law 2: M.SelectMany(Monad) == M
38
        Reader<Tuple<bool, string>, int> M = c => 1 + c.Item2.Length;
39
        left = M.SelectMany(ReaderExtensions.Reader<Tuple<bool, string>, int>);
40
        right = M;
41
        Assert.AreEqual(left(config), right(config));
42
        // Monad law 3: M.SelectMany(f1).SelectMany(f2) == M.SelectMany(x => f1(x).SelectMany(f2))
43
        Func<int, Reader<Tuple<bool, string>, int>> addLength = x => c => x + c.Item2.Length;
44
        left = M.SelectMany(addOne).SelectMany(addLength);
45
        right = M.SelectMany(x => addOne(x).SelectMany(addLength));
46
        Assert.AreEqual(left(config), right(config));
47
    }
48
}