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

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

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

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

1
// Impure.
2
public static partial class TaskExtensions
3
{
4
    public static async Task<TResult> Apply<TSource, TResult>
5
        (this Task<Func<TSource, TResult>> selectorFunctor, Task<TSource> source) =>
6
            (await selectorFunctor)(await source);
7

8
    public static Task<T> Task<T>
9
        (this T value) => System.Threading.Tasks.Task.FromResult(value);
10

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

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

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

13
        // f.Functor().Apply(F) == F.Select(f)
14
        Assert.AreEqual(addOne.Tuple().Apply(1.Tuple()).Item1, 1.Tuple().Select(addOne).Item1);
15
        // id.Functor().Apply(F) == F
16
        Func<int, int> id = Functions.Id;
17
        Assert.AreEqual(id.Tuple().Apply(1.Tuple()).Item1, 1.Tuple().Item1);
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
        Tuple<int> left1 = o.Tuple().Apply(addOne.Tuple()).Apply(addTwo.Tuple()).Apply(1.Tuple());
23
        Tuple<int> right1 = addOne.Tuple().Apply(addTwo.Tuple().Apply(1.Tuple()));
24
        Assert.AreEqual(left1.Item1, right1.Item1);
25
        // f.Functor().Apply(a.Functor()) == f(a).Functor()
26
        Assert.AreEqual(addOne.Tuple().Apply(1.Tuple()).Item1, addOne(1).Tuple().Item1);
27
        // F.Apply(a.Functor()) == (f => f(a)).Functor().Apply(F)
28
        Tuple<int> left2 = addOne.Tuple().Apply(1.Tuple());
29
        Tuple<int> right2 = new Func<Func<int, int>, int>(f => f(1)).Tuple().Apply(addOne.Tuple());
30
        Assert.AreEqual(left2.Item1, right2.Item1);
31
    }
32

33
    [TestMethod()]
34
    public void HotTaskTest()
35
    {
36
        bool isExecuted1 = false;
37
        Func<int, int> addOne = x => { isExecuted1 = true; return x + 1; };
38
        Task<Func<int, int>> hotAddOne = Task.Run(() => addOne);
39
        Task<int> hotTwo = Task.Run(() => 2);
40
        Task<int> query1 = hotAddOne.Apply(hotTwo);
41
        Assert.AreEqual(2 + 1, query1.Result);
42
        Assert.IsTrue(isExecuted1);
43

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

64
    [TestMethod()]
65
    public void ColdTaskTest()
66
    {
67
        bool isExecuted1 = false;
68
        bool isExecuted2 = false;
69
        Func<int, int> addOne = x => { isExecuted1 = true; return x + 1; };
70
        Task<Func<int, int>> coldAddOne = new Task<Func<int, int>>(() => addOne);
71
        Task<int> coldTwo = new Task<int>(() => { isExecuted2 = true; return 2; });
72
        Task<int> query2 = coldAddOne.Apply(coldTwo);
73
        Assert.IsFalse(isExecuted1); // Laziness.
74
        Assert.IsFalse(isExecuted2); // Laziness.
75
        coldAddOne.Start(); // Execution.
76
        coldTwo.Start(); // Execution.
77
        Assert.AreEqual(2 + 1, query2.Result);
78
        Assert.IsTrue(isExecuted1);
79
        Assert.IsTrue(isExecuted2);
80

81
        // f.Functor().Apply(F) == F.Select(f)
82
        coldAddOne = new Task<Func<int, int>>(() => addOne);
83
        coldTwo = new Task<int>(() => 2);
84
        Task<int> left = coldAddOne.Apply(coldTwo);
85
        Task<int> right = coldTwo.Select(addOne);
86
        coldAddOne.Start();
87
        coldTwo.Start();
88
        Assert.AreEqual(left.Result, right.Result);
89
        // id.Functor().Apply(F) == F
90
        Func<int, int> id = Functions.Id;
91
        Task<Func<int, int>> coldId = new Task<Func<int, int>>(() => id);
92
        coldTwo = new Task<int>(() => 2);
93
        left = coldId.Apply(coldTwo);
94
        right = coldTwo;
95
        coldId.Start();
96
        coldTwo.Start();
97
        Assert.AreEqual(left.Result, right.Result);
98
        // o.Functor().Apply(F1).Apply(F2).Apply(F3) == F1.Apply(F2.Apply(F3))
99
        coldAddOne = new Task<Func<int, int>>(() => addOne);
100
        Func<int, int> addTwo = x => x + 2;
101
        Task<Func<int, int>> coldAddTwo = new Task<Func<int, int>>(() => addTwo);
102
        Func<Func<int, int>, Func<Func<int, int>, Func<int, int>>> o =
103
            new Func<Func<int, int>, Func<int, int>, Func<int, int>>(FuncExtensions.o).Curry();
104
        Task<Func<Func<int, int>, Func<Func<int, int>, Func<int, int>>>> coldComposite =
105
            new Task<Func<Func<int, int>, Func<Func<int, int>, Func<int, int>>>>(() => o);
106
        coldTwo = new Task<int>(() => 2);
107
        left = coldComposite.Apply(coldAddOne).Apply(coldAddTwo).Apply(coldTwo);
108
        right = coldAddOne.Apply(coldAddTwo.Apply(coldTwo));
109
        coldComposite.Start();
110
        coldAddOne.Start();
111
        coldAddTwo.Start();
112
        coldTwo.Start();
113
        Assert.AreEqual(left.Result, right.Result);
114
        // f.Functor().Apply(a.Functor()) == f(a).Functor()
115
        coldAddOne = new Task<Func<int, int>>(() => addOne);
116
        coldTwo = new Task<int>(() => 2);
117
        left = coldAddOne.Apply(coldTwo);
118
        right = new Task<int>(() => addOne(2));
119
        coldAddOne.Start();
120
        coldTwo.Start();
121
        right.Start();
122
        Assert.AreEqual(left.Result, right.Result);
123
        // F.Apply(a.Functor()) == (f => f(a)).Functor().Apply(F)
124
        coldAddOne = new Task<Func<int, int>>(() => addOne);
125
        coldTwo = new Task<int>(() => 2);
126
        left = coldAddOne.Apply(coldTwo);
127
        Task<Func<Func<int, int>, int>> coldApplyTwo =
128
            new Task<Func<Func<int, int>, int>>(() => f => f(2));
129
        right = coldApplyTwo.Apply(coldAddOne);
130
        coldAddOne.Start();
131
        coldTwo.Start();
132
        coldApplyTwo.Start();
133
        Assert.AreEqual(left.Result, right.Result);
134
    }
135
}