Category Theory via C# (12) More Monoidal Functors: Lazy<>, Func<> And Nullable<>

Lazy<> should be the simplest monoid functor - it is just the lazy version of Tuple<>. And in these posts it will be considered as the Id<> monoidal functor.

1
// [Pure]
2
public static partial class LazyExtensions
3
{
4
    public static Lazy<TResult> Apply<TSource, TResult>
5
        (this Lazy<Func<TSource, TResult>> selectorFunctor, Lazy<TSource> source) =>
6
            new Lazy<TResult>(() => selectorFunctor.Value(source.Value));
7

8
    public static Lazy<T> Lazy<T>
9
        (this T value) => new Lazy<T>(() => value);
10

11
    // φ: Lazy<Lazy<T1>, Lazy<T2>> => Lazy<Lazy<T1, T2>>
12
    public static Lazy<Lazy<T1, T2>> Binary<T1, T2>
13
        (this Lazy<Lazy<T1>, Lazy<T2>> binaryFunctor) =>
14
            new Func<T1, Func<T2, Lazy<T1, T2>>>(x => y => new Lazy<T1, T2>(x, y))
15
                .Lazy()
16
                .Apply(binaryFunctor.Value1)
17
                .Apply(binaryFunctor.Value2);
18

19
    // ι: Unit -> Lazy<Unit>
20
    public static Lazy<Unit> Unit
21
        (Unit unit) => unit.Lazy();
22
}

Tuple<> is similar to the Haskell Id Applicative. The usage will be demonstrated in later tests unit.

Func<> monoidal functor#

Func<> is also monoidal functor:

1
// [Pure]
2
public static partial class FuncExtensions
3
{
4
    public static Func<TResult> Apply<TSource, TResult>
5
        (this Func<Func<TSource, TResult>> selectorFunctor, Func<TSource> source) =>
6
            () => selectorFunctor()(source());
7

8
    public static Func<T> Func<T>
9
        (this T value) => () => value;
10

11
    // φ: Lazy<Func<T1>, Func<T2>> => Func<Lazy<T1, T2>>
12
    public static Func<Lazy<T1, T2>> Binary<T1, T2>
13
        (this Lazy<Func<T1>, Func<T2>> binaryFunctor) =>
14
            FuncExtensions.Func(new Func<T1, Func<T2, Lazy<T1, T2>>>(x => y => new Lazy<T1, T2>(x, y)))
15
                .Apply(binaryFunctor.Value1)
16
                .Apply(binaryFunctor.Value2);
17

18
    // ι: Unit -> Func<Unit>
19
    public static Func<Unit> Unit
20
        (Unit unit) => unit.Func();
21
}

Nullable<> monoidal functor#

Nullable<> created previously is monoidal functor too:

1
// [Pure]
2
public static partial class NullableExtensions
3
{
4
    public static Nullable<TResult> Apply<TSource, TResult>
5
        (this Nullable<Func<TSource, TResult>> selectorFunctor, Nullable<TSource> source) =>
6
            new Nullable<TResult>(() => selectorFunctor.HasValue && source.HasValue ?
7
                new Tuple<bool, TResult>(true, selectorFunctor.Value(source.Value)) :
8
                new Tuple<bool, TResult>(false, default(TResult)));
9

10
    public static Nullable<T> Nullable<T>
11
        (this T value) => new Nullable<T>(() => Tuple.Create(true, value));
12

13
    // φ: Lazy<Nullable<T1>, Nullable<T2>> => Nullable<Lazy<T1, T2>>
14
    public static Nullable<Lazy<T1, T2>> Binary<T1, T2>
15
        (this Lazy<Nullable<T1>, Nullable<T2>> binaryFunctor) =>
16
            new Func<T1, Func<T2, Lazy<T1, T2>>>(x => y => new Lazy<T1, T2>(x, y))
17
                .Nullable()
18
                .Apply(binaryFunctor.Value1)
19
                .Apply(binaryFunctor.Value2);
20

21
    // ι: Unit -> Nullable<Unit>
22
    public static Nullable<Unit> Unit
23
        (Unit unit) => unit.Nullable();
24
}

Unit tests#

1
public partial class MonoidalFunctorTests
2
{
3
    [TestMethod()]
4
    public void LazyTest()
5
    {
6
        bool isExecuted1 = false;
7
        Func<int, int> addOne = x => { isExecuted1 = true; return x + 1; };
8
        Lazy<int> query1 = addOne.Lazy().Apply(2.Lazy());
9
        Assert.IsFalse(isExecuted1); // Laziness.
10
        Assert.AreEqual(2 + 1, query1.Value); // Execution.
11
        Assert.IsTrue(isExecuted1);
12

13
        // f.Functor().Apply(F) == F.Select(f)
14
        Assert.AreEqual(addOne.Lazy().Apply(1.Lazy()).Value, 1.Lazy().Select(addOne).Value);
15
        // id.Functor().Apply(F) == F
16
        Func<int, int> id = Functions.Id;
17
        Assert.AreEqual(id.Lazy().Apply(1.Lazy()).Value, 1.Lazy().Value);
18
        // o.Functor().Apply(F1).Apply(F2).Apply(F3) == F1.Apply(F2.Apply(F3))
19
        Func<int, int> addTwo = x => x + 2;
20
        Func<Func<int, int>, Func<Func<int, int>, Func<int, int>>> o =
21
            new Func<Func<int, int>, Func<int, int>, Func<int, int>>(FuncExtensions.o).Curry();
22
        Lazy<int> left1 = o.Lazy().Apply(addOne.Lazy()).Apply(addTwo.Lazy()).Apply(1.Lazy());
23
        Lazy<int> right1 = addOne.Lazy().Apply(addTwo.Lazy().Apply(1.Lazy()));
24
        Assert.AreEqual(left1.Value, right1.Value);
25
        // f.Functor().Apply(a.Functor()) == f(a).Functor()
26
        Assert.AreEqual(addOne.Lazy().Apply(1.Lazy()).Value, addOne(1).Lazy().Value);
27
        // F.Apply(a.Functor()) == (f => f(a)).Functor().Apply(F)
28
        Lazy<int> left2 = addOne.Lazy().Apply(1.Lazy());
29
        Lazy<int> right2 = new Func<Func<int, int>, int>(f => f(1)).Lazy().Apply(addOne.Lazy());
30
        Assert.AreEqual(left2.Value, right2.Value);
31
    }
32

33
    [TestMethod()]
34
    public void FuncTest()
35
    {
36
        bool isExecuted1 = false;
37
        Func<int, int> addOne = x => { isExecuted1 = true; return x + 1; };
38
        Func<int> query1 = FuncExtensions.Func(addOne).Apply(2.Func());
39
        Assert.IsFalse(isExecuted1); // Laziness.
40
        Assert.AreEqual(addOne(2), query1()); // Execution.
41
        Assert.IsTrue(isExecuted1);
42

43
        // f.Functor().Apply(F) == F.Select(f)
44
        Assert.AreEqual(FuncExtensions.Func(addOne).Apply(1.Func())(), 1.Func().Select(addOne)());
45
        // id.Functor().Apply(F) == F
46
        Func<int, int> id = Functions.Id;
47
        Assert.AreEqual(FuncExtensions.Func(id).Apply(1.Func())(), 1.Func()());
48
        // o.Functor().Apply(F1).Apply(F2).Apply(F3) == F1.Apply(F2.Apply(F3))
49
        Func<int, int> addTwo = x => x + 2;
50
        Func<Func<int, int>, Func<Func<int, int>, Func<int, int>>> o =
51
            new Func<Func<int, int>, Func<int, int>, Func<int, int>>(FuncExtensions.o).Curry();
52
        Func<int> left1 = FuncExtensions.Func(o).Apply(FuncExtensions.Func(addOne)).Apply(FuncExtensions.Func(addTwo)).Apply(1.Func());
53
        Func<int> right1 = FuncExtensions.Func(addOne).Apply(FuncExtensions.Func(addTwo).Apply(1.Func()));
54
        Assert.AreEqual(left1(), right1());
55
        // f.Functor().Apply(a.Functor()) == f(a).Functor()
56
        Assert.AreEqual(FuncExtensions.Func(addOne).Apply(1.Func())(), addOne(1).Func()());
57
        // F.Apply(a.Functor()) == (f => f(a)).Functor().Apply(F)
58
        Func<int> left2 = FuncExtensions.Func(addOne).Apply(1.Func());
59
        Func<int> right2 = FuncExtensions.Func(new Func<Func<int, int>, int>(f => f(1))).Apply(FuncExtensions.Func(addOne));
60
        Assert.AreEqual(left2(), right2());
61
    }
62

63
    [TestMethod()]
64
    public void FuncTest2()
65
    {
66
        bool isExecuted1 = false;
67
        Func<int, Func<int, string>> add = x => y =>
68
            { isExecuted1 = true; return (x + y).ToString(CultureInfo.InvariantCulture); };
69
        Func<string> query2 = FuncExtensions.Func(add).Apply(1.Func()).Apply(2.Func());
70
        Assert.IsFalse(isExecuted1); // Laziness.
71
        Assert.AreEqual(add(1)(2), query2()); // Execution.
72
        Assert.IsTrue(isExecuted1);
73

74
        // f.Functor().Apply(F) == F.Select(f)
75
        Assert.AreEqual(FuncExtensions.Func(add).Apply(1.Func())()(2), 1.Func().Select(add)()(2));
76
        // id.Functor().Apply(F) == F
77
        Func<int, int> id = Functions.Id;
78
        Assert.AreEqual(FuncExtensions.Func(id).Apply(1.Func())(), 1.Func()());
79
        // o.Functor().Apply(F1).Apply(F2).Apply(F3) == F1.Apply(F2.Apply(F3))
80
        Func<Func<int, string>, Func<int, int>> length = f => x => f(x).Length;
81
        Func<Func<Func<int, string>, Func<int, int>>, Func<Func<int, Func<int, string>>, Func<int, Func<int, int>>>> o =
82
            new Func<Func<Func<int, string>, Func<int, int>>, Func<int, Func<int, string>>, Func<int, Func<int, int>>>(FuncExtensions.o).Curry();
83
        Func<Func<int, int>> left1 = FuncExtensions.Func(o).Apply(FuncExtensions.Func(length)).Apply(FuncExtensions.Func(add)).Apply(1.Func());
84
        Func<Func<int, int>> right1 = FuncExtensions.Func(length).Apply(FuncExtensions.Func(add).Apply(1.Func()));
85
        Assert.AreEqual(left1()(2), right1()(2));
86
        // f.Functor().Apply(a.Functor()) == f(a).Functor()
87
        Assert.AreEqual(FuncExtensions.Func(add).Apply(1.Func())()(2), FuncExtensions.Func(add(1))()(2));
88
        // F.Apply(a.Functor()) == (f => f(a)).Functor().Apply(F)
89
        Func<Func<int, string>> left2 = FuncExtensions.Func(add).Apply(1.Func());
90
        Func<Func<int, string>> right2 = FuncExtensions.Func(new Func<Func<int, Func<int, string>>, Func<int, string>>(
91
                f => f(1))).Apply(FuncExtensions.Func(add));
92
        Assert.AreEqual(left2()(2), right2()(2));
93

94
        bool isExecuted3 = false;
95
        Func<string> consoleReadLine1 = () => "a";
96
        Func<string> consoleReadLine2 = () => "b";
97
        Func<string, Func<string, string>> concat = x => y =>
98
            { isExecuted3 = true; return string.Concat(x, y); };
99
        Func<string> concatLines = FuncExtensions.Func(concat).Apply(consoleReadLine1).Apply(consoleReadLine2);
100
        Assert.IsFalse(isExecuted3); // Laziness.
101
        Assert.AreEqual(string.Concat(consoleReadLine1(), consoleReadLine2()), concatLines());
102
        Assert.IsTrue(isExecuted3);
103
    }
104

105
    [TestMethod()]
106
    public void NullableTest()
107
    {
108
        bool isExecuted1 = false;
109
        Func<int, int> addOne = x => { isExecuted1 = true; return x + 1; };
110
        Nullable<int> query1 = addOne.Nullable().Apply(2.Nullable());
111
        Assert.IsFalse(isExecuted1); // Laziness.
112
        Assert.IsTrue(query1.HasValue); // Execution.
113
        Assert.AreEqual(addOne(2), query1.Value);
114
        Assert.IsTrue(isExecuted1);
115

116
        // f.Functor().Apply(F) == F.Select(f)
117
        Assert.AreEqual(addOne.Nullable().Apply(1.Nullable()).Value, 1.Nullable().Select(addOne).Value);
118
        // id.Functor().Apply(F) == F
119
        Func<int, int> id = Functions.Id;
120
        Assert.AreEqual(id.Nullable().Apply(1.Nullable()).Value, 1.Nullable().Value);
121
        // o.Functor().Apply(F1).Apply(F2).Apply(F3) == F1.Apply(F2.Apply(F3))
122
        Func<int, int> addTwo = x => x + 2;
123
        Func<Func<int, int>, Func<Func<int, int>, Func<int, int>>> o =
124
            new Func<Func<int, int>, Func<int, int>, Func<int, int>>(FuncExtensions.o).Curry();
125
        Nullable<int> left1 = o.Nullable().Apply(addOne.Nullable()).Apply(addTwo.Nullable()).Apply(1.Nullable());
126
        Nullable<int> right1 = addOne.Nullable().Apply(addTwo.Nullable().Apply(1.Nullable()));
127
        Assert.AreEqual(left1.Value, right1.Value);
128
        // f.Functor().Apply(a.Functor()) == f(a).Functor()
129
        Assert.AreEqual(addOne.Nullable().Apply(1.Nullable()).Value, addOne(1).Nullable().Value);
130
        // F.Apply(a.Functor()) == (f => f(a)).Functor().Apply(F)
131
        Nullable<int> left2 = addOne.Nullable().Apply(1.Nullable());
132
        Nullable<int> right2 = new Func<Func<int, int>, int>(f => f(1)).Nullable().Apply(addOne.Nullable());
133
        Assert.AreEqual(left2.Value, right2.Value);
134

135
        bool isExecuted2 = false;
136
        Func<int, int> addTwo2 = x => { isExecuted2 = true; return x + 2; };
137
        Nullable<int> query2 = addTwo2.Nullable().Apply(new Nullable<int>());
138
        Assert.IsFalse(isExecuted2); // Laziness.
139
        Assert.IsFalse(query2.HasValue); // Execution.
140
        Assert.IsFalse(isExecuted2);
141
    }
142
}