Category Theory via C# (15) IEnumerable<> Monad And LINQ: SelectMany For All

[LINQ via C# series]#

[Category Theory via C# series]#

Latest version: https://weblogs.asp.net/dixin/category-theory-via-csharp-7-monad-and-linq-to-monads#

Previous part introduced SelectMany for monad IEnumerable<>. Actually SelectMany is more than meets the eye, and can be used to implement other LINQ queries.

Query methods implemented by SelectMany#

This part will demonstrate how to use SelectMany to implement following LINQ query methods:

Restriction: Where
Projection: Select
Join: Join, GroupJoin
Grouping: GroupBy
Set: Zip, Distinct, Union, Intersect, Except
Partitioning: Take, Skip, TakeWhile, SkipWhile
Cancatening: Concat

First, create a help method to make the code shorter:

1
[Pure]
2
public static partial class EnumerableSelectManyExtensions
3
{
4
    // value.Enumerable(isNotEmpty) is the alias of (isNotEmpty ? value.Enumerable() : Enumerable.Empty<TSource>())
5
    public static IEnumerable<TSource> Enumerable<TSource>(this TSource value, bool isNotEmpty = false)
6
    {
7
        // return isNotEmpty ? EnumerableEx.Return(value) : Enumerable.Empty<TSource>();
8
        if (isNotEmpty)
9
        {
10
            yield return value;
11
        }
12
    }
13
}

And here comes this long list of 15 methods:

1
public static IEnumerable<TSource> Concat<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
2
{
3
    return new IEnumerable<TSource>[] { first, second }
4
        .SelectMany(Functions.Id);
5
}
6

7
public static IEnumerable<TSource> Distinct<TSource>(
8
    this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
9
{
10
    HashSet<TSource> hashSet = new HashSet<TSource>(comparer);
11
    return source
12
        .SelectMany(value => value.Enumerable(hashSet.Add(value)));
13
}
14

15
public static IEnumerable<TSource> Except<TSource>(
16
    this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
17
{
18
    HashSet<TSource> hashSet = new HashSet<TSource>(second, comparer);
19
    return first
20
        .SelectMany(firstValue => firstValue.Enumerable(hashSet.Add(firstValue)));
21
}
22

23
public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(
24
    this IEnumerable<TSource> source,
25
    Func<TSource, TKey> keySelector,
26
    Func<TSource, TElement> elementSelector,
27
    IEqualityComparer<TKey> comparer)
28
{
29
    // return source.ToLookup(keySelector, elementSelector, comparer);
30
    HashSet<TKey> hashSet = new HashSet<TKey>(comparer);
31
    return source
32
        .SelectMany(value => keySelector(value).Enumerable())
33
        .SelectMany(key => key.Enumerable(hashSet.Add(key)))
34
        // Microsoft.FSharp.Linq.RuntimeHelpers.Grouping<K, T>
35
        .SelectMany(key => new Grouping<TKey, TElement>(key, source
36
            // SelectMany inside SelectMany. Time complexity is O(N * N).
37
            .SelectMany(value => elementSelector(value).Enumerable(comparer.Equals(key, keySelector(value))))).Enumerable());
38
}
39

40
public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(
41
    this IEnumerable<TOuter> outer,
42
    IEnumerable<TInner> inner,
43
    Func<TOuter, TKey> outerKeySelector,
44
    Func<TInner, TKey> innerKeySelector,
45
    Func<TOuter, IEnumerable<TInner>, TResult> resultSelector,
46
    IEqualityComparer<TKey> comparer)
47
{
48
    ILookup<TKey, TInner> lookup = inner.ToLookup(innerKeySelector, comparer); // Lookup<TKey, TInner> cannot be created by public API.
49
    return outer
50
        .SelectMany(outerValue => resultSelector(outerValue, lookup[outerKeySelector(outerValue)]).Enumerable());
51
}
52

53
public static IEnumerable<TSource> Intersect<TSource>(
54
    this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
55
{
56
    HashSet<TSource> hashSet = new HashSet<TSource>(second, comparer);
57
    return first
58
        .SelectMany(firstValue => firstValue.Enumerable(hashSet.Remove(firstValue)));
59
}
60

61
public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(
62
    this IEnumerable<TOuter> outer,
63
    IEnumerable<TInner> inner,
64
    Func<TOuter, TKey> outerKeySelector,
65
    Func<TInner, TKey> innerKeySelector,
66
    Func<TOuter, TInner, TResult> resultSelector,
67
    IEqualityComparer<TKey> comparer)
68
{
69
    ILookup<TKey, TInner> lookup = inner.ToLookup(innerKeySelector, comparer); // Lookup<TKey, TInner> cannot be created by public API.
70
    return outer
71
        .SelectMany(outerValue => lookup[outerKeySelector(outerValue)]
72
            .SelectMany(innerValue => resultSelector(outerValue, innerValue).Enumerable()));
73
}
74

75
public static IEnumerable<TResult> Select<TSource, TResult>(
76
    this IEnumerable<TSource> source, Func<TSource, TResult> selector)
77
{
78
    return source.SelectMany(
79
        sourceValue => selector(sourceValue).Enumerable());
80
}
81

82
public static IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> source, int count)
83
{
84
    return source
85
        .SelectMany((value, index) => value.Enumerable(index >= count));
86
}
87

88
public static IEnumerable<TSource> SkipWhile<TSource>(
89
    this IEnumerable<TSource> source, Func<TSource, bool> predicate)
90
{
91
    bool flag = false;
92
    return source
93
        .SelectMany(value =>
94
        {
95
            if (!flag && !predicate(value))
96
            {
97
                flag = true; // Imperative.
98
            }
99

100
            return value.Enumerable(flag);
101
        });
102
}
103

104
public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, int count)
105
{
106
    return source
107
        .SelectMany((value, index) => value.Enumerable(index < count));
108
}
109

110
public static IEnumerable<TSource> TakeWhile<TSource>(
111
    this IEnumerable<TSource> source, Func<TSource, bool> predicate)
112
{
113
    bool flag = true;
114
    return source
115
        .SelectMany(value =>
116
        {
117
            if (!predicate(value))
118
            {
119
                flag = false; // Imperative.
120
            }
121

122
            return value.Enumerable(flag);
123
        });
124
}
125

126
public static IEnumerable<TSource> Union<TSource>(
127
    this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
128
{
129
    HashSet<TSource> hashSet = new HashSet<TSource>(comparer);
130
    return new IEnumerable<TSource>[] { first, second }
131
        .SelectMany(Functions.Id)
132
        .SelectMany(value => value.Enumerable(hashSet.Add(value)));
133
}
134

135
public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
136
{
137
    return source
138
        .SelectMany(value => value.Enumerable(predicate(value)));
139
}
140

141
public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(
142
    this IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
143
{
144
    return first
145
        .SelectMany((firstValue, index) => second
146
            // SelectMany inside SelectMany. Time complexity is O(N * N).
147
            .SelectMany((value, index2) => value.Enumerable(index2 == index)), resultSelector);
148
}

Again these code are just for demonstration purpose. The performance of above code is no better than the built-in implementation in System.Linq.Enumerable. Also, some of above SelectMany code is imperative, for example:

Skip, Take, Zip use the index
SkipWhile and TakeWhile use a variable

So these SelectMany usages are not authentically functional.

Query methods in LINQ syntax#

Above implementations in LINQ syntax:

1
public static IEnumerable<TSource> Concat<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
2
{
3
    return from enumerable in new IEnumerable<TSource>[] { first, second }
4
           from value in enumerable
5
           select value;
6
}
7

8
public static IEnumerable<TSource> Distinct<TSource>(
9
    this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
10
{
11
    HashSet<TSource> hashSet = new HashSet<TSource>(comparer);
12
    return from value in source
13
           // where hashSet.Add(value)
14
           from distinct in value.Enumerable(hashSet.Add(value))
15
           select distinct;
16
}
17

18
public static IEnumerable<TSource> Except<TSource>(
19
    this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
20
{
21
    HashSet<TSource> hashSet = new HashSet<TSource>(second, comparer);
22
    return from value in first
23
           // where hashSet.Add(value)
24
           from except in value.Enumerable(hashSet.Add(value))
25
           select except;
26
}
27

28
public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(
29
    this IEnumerable<TSource> source,
30
    Func<TSource, TKey> keySelector,
31
    Func<TSource, TElement> elementSelector,
32
    IEqualityComparer<TKey> comparer)
33
{
34
    HashSet<TKey> hashSet = new HashSet<TKey>(comparer);
35
    return from value in source
36
           let key = keySelector(value)
37
           // where hashSet.Add(key)
38
           from distinctKey in key.Enumerable(hashSet.Add(key))
39
           select new Grouping<TKey, TElement>(
40
               distinctKey,
41
               from value2 in source
42
               // where comparer.Equals(distinctKey, keySelector(value2))
43
               from element in elementSelector(value).Enumerable(comparer.Equals(key, keySelector(value2)))
44
               select elementSelector(value2));
45
}
46

47
public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(
48
    this IEnumerable<TOuter> outer,
49
    IEnumerable<TInner> inner,
50
    Func<TOuter, TKey> outerKeySelector,
51
    Func<TInner, TKey> innerKeySelector,
52
    Func<TOuter, IEnumerable<TInner>, TResult> resultSelector,
53
    IEqualityComparer<TKey> comparer)
54
{
55
    ILookup<TKey, TInner> lookup = inner.ToLookup(innerKeySelector, comparer);
56
    return from outerValue in outer
57
           // select resultSelector(outerValue, lookup[outerKeySelector(outerValue)])
58
           from result in resultSelector(outerValue, lookup[outerKeySelector(outerValue)]).Enumerable()
59
           select result;
60
}
61

62
public static IEnumerable<TSource> Intersect<TSource>(
63
    this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
64
{
65
    HashSet<TSource> hashSet = new HashSet<TSource>(second, comparer);
66
    return from firstValue in first
67
           // where hashSet.Remove(firstValue)
68
           from intersect in firstValue.Enumerable(hashSet.Remove(firstValue))
69
           select intersect;
70
}
71

72
public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(
73
    this IEnumerable<TOuter> outer,
74
    IEnumerable<TInner> inner,
75
    Func<TOuter, TKey> outerKeySelector,
76
    Func<TInner, TKey> innerKeySelector,
77
    Func<TOuter, TInner, TResult> resultSelector,
78
    IEqualityComparer<TKey> comparer)
79
{
80
    ILookup<TKey, TInner> lookup = inner.ToLookup(innerKeySelector, comparer); // Lookup<TKey, TInner> cannot be created by public API.
81
    return from outerValue in outer
82
           from result in
83
               (from innerValue in lookup[outerKeySelector(outerValue)]
84
               // select resultSelector(outerValue, innerValue)
85
               from result2 in resultSelector(outerValue, innerValue).Enumerable()
86
               select result2)
87
           select result;
88
}
89

90
public static IEnumerable<TResult> Select<TSource, TResult>(
91
    this IEnumerable<TSource> source, Func<TSource, TResult> selector)
92
{
93
    return from value in source
94
           // select selector(value)
95
           from result in selector(value).Enumerable()
96
           select result;
97
}
98

99
public static IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> source, int count)
100
{
101
    int index = 0;
102
    return from value in source
103
           // where index++ >= count
104
           from result in value.Enumerable(index++ >= count)
105
           select result;
106
}
107

108
public static IEnumerable<TSource> SkipWhile<TSource>(
109
    this IEnumerable<TSource> source, Func<TSource, bool> predicate)
110
{
111
    bool flag = false;
112
    return from value in source
113
           let _ = (!flag && !predicate(value)) && (flag = true)
114
           from result in value.Enumerable(flag)
115
           select result;
116
}
117

118
public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, int count)
119
{
120
    int index = 0;
121
    return from value in source
122
           // where index++ < count
123
           from result in value.Enumerable(index++ < count)
124
           select result;
125
}
126

127
public static IEnumerable<TSource> TakeWhile<TSource>(
128
    this IEnumerable<TSource> source, Func<TSource, bool> predicate)
129
{
130
    bool flag = true;
131
    return from value in source
132
           let _ = (predicate(value)) || (flag = false)
133
           from result in value.Enumerable(flag)
134
           select result;
135
}
136

137
public static IEnumerable<TSource> Union<TSource>(
138
    this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
139
{
140
    HashSet<TSource> hashSet = new HashSet<TSource>(comparer);
141
    return from enumerable in new IEnumerable<TSource>[] { first, second }
142
           from value in enumerable
143
           // where hashSet.Add(value)
144
           from result in value.Enumerable(hashSet.Add(value))
145
           select result;
146
}
147

148
public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
149
{
150
    return from value in source
151
           from result in value.Enumerable(predicate(value))
152
           select result;
153
}
154

155
public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(
156
    this IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
157
{
158
    int firstIndex = 0;
159
    int secondIndex = 0;
160
    return from firstValue in first
161
           let currentFirstIndex = firstIndex++
162
           let _ = secondIndex = 0
163
           from secondResult in
164
               (from secondValue in second
165
               // where firstIndex2 == secondIndex++
166
               // let secondIndex3 = secondIndex++
167
               from secondResult in secondValue.Enumerable(currentFirstIndex == secondIndex++)
168
               select secondResult)
169
           select resultSelector(firstValue, secondResult);
170
}

Please notice that Skip, Take, Zip, SkipWhile and TakeWhile uses let clause as trick.

Unit tests#

Once again, a long tedious list of test code:

1
[TestClass()]
2
public class EnumerableSelectManyExtensionsTests
3
{
4
    [TestMethod()]
5
    public void ConcatTest()
6
    {
7
        int[] first = new int[] { 0, 1, 2 };
8
        int[] second = new int[] { 3, 4, 5 };
9
        EnumerableAssert.AreEqual(
10
            Enumerable.Concat(first, second),
11
            EnumerableSelectManyExtensions.Concat(first, second));
12

13
        first = new int[] { };
14
        second = new int[] { 3, 4, 5 };
15
        EnumerableAssert.AreEqual(
16
            Enumerable.Concat(first, second),
17
            EnumerableSelectManyExtensions.Concat(first, second));
18

19
        first = new int[] { 0, 1, 2 };
20
        second = new int[] { };
21
        EnumerableAssert.AreEqual(
22
            Enumerable.Concat(first, second),
23
            EnumerableSelectManyExtensions.Concat(first, second));
24
    }
25

26
    [TestMethod()]
27
    public void DistinctTest()
28
    {
29
        int[] enumerable = new int[] { 0, 1, 2 };
30
        EnumerableAssert.AreEqual(
31
            Enumerable.Distinct(enumerable),
32
            EnumerableSelectManyExtensions.Distinct(enumerable, EqualityComparer<int>.Default));
33

34
        enumerable = new int[] { 0, 1, 1, 1, 2, 2 };
35
        EnumerableAssert.AreEqual(
36
            Enumerable.Distinct(enumerable),
37
            EnumerableSelectManyExtensions.Distinct(enumerable, EqualityComparer<int>.Default));
38
    }
39

40
    [TestMethod()]
41
    public void ExceptTest()
42
    {
43
        int[] first = new int[] { 0, 1, 2 };
44
        int[] second = new int[] { 3, 4, 5 };
45
        EnumerableAssert.AreEqual(
46
            Enumerable.Except(first, second),
47
            EnumerableSelectManyExtensions.Except(first, second, EqualityComparer<int>.Default));
48

49
        first = new int[] { 0, 1, 2 };
50
        second = new int[] { };
51
        EnumerableAssert.AreEqual(
52
            Enumerable.Except(first, second),
53
            EnumerableSelectManyExtensions.Except(first, second, EqualityComparer<int>.Default));
54

55
        first = new int[] { };
56
        second = new int[] { 3, 4, 5 };
57
        EnumerableAssert.AreEqual(
58
            Enumerable.Except(first, second),
59
            EnumerableSelectManyExtensions.Except(first, second, EqualityComparer<int>.Default));
60

61
        first = new int[] { 0, 1, 2 };
62
        second = new int[] { 2, 3, 4 };
63
        EnumerableAssert.AreEqual(
64
            Enumerable.Except(first, second),
65
            EnumerableSelectManyExtensions.Except(first, second, EqualityComparer<int>.Default));
66
    }
67

68
    [TestMethod()]
69
    public void GroupByTest()
70
    {
71
        int[] enumerable = new int[] { 0, 1, 2, 4, 5, 6 };
72
        IGrouping<int, int>[] expected = Enumerable.GroupBy(enumerable, value => value % 3, value => value).ToArray();
73
        IGrouping<int, int>[] actual = EnumerableSelectManyExtensions.GroupBy(enumerable, value => value % 3, value => value, EqualityComparer<int>.Default).ToArray();
74
        Assert.AreEqual(expected.Count(), actual.Count());
75
        expected.ForEach((group, index) =>
76
            {
77
                Assert.AreEqual(group.Key, actual[index].Key);
78
                EnumerableAssert.AreEqual(group, actual[index]);
79
            });
80

81
        enumerable = new int[] { };
82
        expected = Enumerable.GroupBy(enumerable, value => value % 3, value => value).ToArray();
83
        actual = EnumerableSelectManyExtensions.GroupBy(enumerable, value => value % 3, value => value, EqualityComparer<int>.Default).ToArray();
84
        Assert.AreEqual(expected.Count(), actual.Count());
85
        expected.ForEach((group, index) =>
86
            {
87
                Assert.AreEqual(group.Key, actual[index].Key);
88
                EnumerableAssert.AreEqual(group, actual[index]);
89
            });
90
    }
91

92
    [TestMethod()]
93
    public void GroupJoinTest()
94
    {
95
        Tuple<int, string>[] categories = new Tuple<int, string>[]
96
                                            {
97
                                                new Tuple<int, string>(1, "A"),
98
                                                new Tuple<int, string>(2, "B"),
99
                                                new Tuple<int, string>(3, "C"),
100
                                            };
101
        Tuple<int, string, int>[] products = new Tuple<int, string, int>[]
102
                                                {
103
                                                    new Tuple<int, string, int>(1, "aa", 1),
104
                                                    new Tuple<int, string, int>(2, "bb", 1),
105
                                                    new Tuple<int, string, int>(3, "cc", 2),
106
                                                    new Tuple<int, string, int>(4, "dd", 2),
107
                                                    new Tuple<int, string, int>(5, "ee", 2),
108
                                                };
109
        Tuple<string, int>[] expected = Enumerable.GroupJoin(
110
            categories,
111
            products,
112
            category => category.Item1,
113
            product => product.Item3,
114
            (category, categoryProducts) => new Tuple<string, int>(category.Item2, categoryProducts.Count())).ToArray();
115
        Tuple<string, int>[] actual = EnumerableSelectManyExtensions.GroupJoin(
116
            categories,
117
            products,
118
            category => category.Item1,
119
            product => product.Item3,
120
            (category, categoryProducts) => new Tuple<string, int>(category.Item2, categoryProducts.Count()),
121
            EqualityComparer<int>.Default).ToArray();
122
        Assert.AreEqual(expected.Count(), actual.Count());
123
        expected.ForEach((product, index) =>
124
            {
125
                Assert.AreEqual(product.Item1, actual[index].Item1);
126
                Assert.AreEqual(product.Item2, actual[index].Item2);
127
            });
128
    }
129

130
    [TestMethod()]
131
    public void IntersectTest()
132
    {
133
        int[] first = new int[] { 0, 1, 2 };
134
        int[] second = new int[] { 3, 4, 5 };
135
        EnumerableAssert.AreEqual(
136
            Enumerable.Intersect(first, second),
137
            EnumerableSelectManyExtensions.Intersect(first, second, EqualityComparer<int>.Default));
138

139
        first = new int[] { 0, 1, 2 };
140
        second = new int[] { };
141
        EnumerableAssert.AreEqual(
142
            Enumerable.Intersect(first, second),
143
            EnumerableSelectManyExtensions.Intersect(first, second, EqualityComparer<int>.Default));
144

145
        first = new int[] { };
146
        second = new int[] { 3, 4, 5 };
147
        EnumerableAssert.AreEqual(
148
            Enumerable.Intersect(first, second),
149
            EnumerableSelectManyExtensions.Intersect(first, second, EqualityComparer<int>.Default));
150

151
        first = new int[] { 0, 1, 2 };
152
        second = new int[] { 2, 3, 4 };
153
        EnumerableAssert.AreEqual(
154
            Enumerable.Intersect(first, second),
155
            EnumerableSelectManyExtensions.Intersect(first, second, EqualityComparer<int>.Default));
156
    }
157

158
    [TestMethod()]
159
    public void JoinTest()
160
    {
161
        Tuple<int, string, int>[] products = new Tuple<int, string, int>[]
162
                                                {
163
                                                    new Tuple<int, string, int>(1, "aa", 1),
164
                                                    new Tuple<int, string, int>(2, "bb", 1),
165
                                                    new Tuple<int, string, int>(3, "cc", 2),
166
                                                    new Tuple<int, string, int>(4, "dd", 2),
167
                                                    new Tuple<int, string, int>(5, "ee", 2),
168
                                                };
169
        Tuple<int, string>[] categories = new Tuple<int, string>[]
170
                                            {
171
                                                new Tuple<int, string>(1, "A"),
172
                                                new Tuple<int, string>(2, "B"),
173
                                                new Tuple<int, string>(3, "C"),
174
                                            };
175
        Tuple<string, string>[] expected = Enumerable.Join(
176
            products,
177
            categories,
178
            product => product.Item3,
179
            category => category.Item1,
180
            (product, category) => new Tuple<string, string>(category.Item2, product.Item2)).ToArray();
181
        Tuple<string, string>[] actual = EnumerableSelectManyExtensions.Join(
182
            products,
183
            categories,
184
            product => product.Item3,
185
            category => category.Item1,
186
            (product, category) => new Tuple<string, string>(category.Item2, product.Item2),
187
            EqualityComparer<int>.Default).ToArray();
188
        Assert.AreEqual(expected.Count(), actual.Count());
189
        expected.ForEach((product, index) =>
190
            {
191
                Assert.AreEqual(product.Item1, actual[index].Item1);
192
                Assert.AreEqual(product.Item2, actual[index].Item2);
193
            });
194

195
        products = new Tuple<int, string, int>[]
196
                                                {
197
                                                    new Tuple<int, string, int>(1, "aa", 1),
198
                                                    new Tuple<int, string, int>(2, "bb", 1),
199
                                                    new Tuple<int, string, int>(3, "cc", 2),
200
                                                    new Tuple<int, string, int>(4, "dd", 2),
201
                                                    new Tuple<int, string, int>(5, "ee", 2),
202
                                                };
203
        categories = new Tuple<int, string>[] { };
204
        expected = Enumerable.Join(
205
            products,
206
            categories,
207
            product => product.Item3,
208
            category => category.Item1,
209
            (product, category) => new Tuple<string, string>(category.Item2, product.Item2)).ToArray();
210
        actual = EnumerableSelectManyExtensions.Join(
211
            products,
212
            categories,
213
            product => product.Item3,
214
            category => category.Item1,
215
            (product, category) => new Tuple<string, string>(category.Item2, product.Item2),
216
            EqualityComparer<int>.Default).ToArray();
217
        Assert.AreEqual(expected.Count(), actual.Count());
218
        expected.ForEach((product, index) =>
219
            {
220
                Assert.AreEqual(product.Item1, actual[index].Item1);
221
                Assert.AreEqual(product.Item2, actual[index].Item2);
222
            });
223

224
        products = new Tuple<int, string, int>[] { };
225
        categories = new Tuple<int, string>[]
226
                                            {
227
                                                new Tuple<int, string>(1, "A"),
228
                                                new Tuple<int, string>(1, "B"),
229
                                                new Tuple<int, string>(1, "C"),
230
                                            };
231
        expected = Enumerable.Join(
232
            products,
233
            categories,
234
            product => product.Item3,
235
            category => category.Item1,
236
            (product, category) => new Tuple<string, string>(category.Item2, product.Item2)).ToArray();
237
        actual = EnumerableSelectManyExtensions.Join(
238
            products,
239
            categories,
240
            product => product.Item3,
241
            category => category.Item1,
242
            (product, category) => new Tuple<string, string>(category.Item2, product.Item2),
243
            EqualityComparer<int>.Default).ToArray();
244
        Assert.AreEqual(expected.Count(), actual.Count());
245
        expected.ForEach((product, index) =>
246
            {
247
                Assert.AreEqual(product.Item1, actual[index].Item1);
248
                Assert.AreEqual(product.Item2, actual[index].Item2);
249
            });
250
    }
251

252
    [TestMethod()]
253
    public void SelectTest()
254
    {
255
        int[] enumerable = new int[] { 0, 1, 2 };
256
        EnumerableAssert.AreEqual(
257
            Enumerable.Select(enumerable, x => x.ToString()),
258
            EnumerableSelectManyExtensions.Select4(enumerable, x => x.ToString()));
259

260
        enumerable = new int[] { };
261
        EnumerableAssert.AreEqual(
262
            Enumerable.Select(enumerable, x => x.ToString()),
263
            EnumerableSelectManyExtensions.Select4(enumerable, x => x.ToString()));
264
    }
265

266
    [TestMethod()]
267
    public void SkipTest()
268
    {
269
        int[] enumerable = new int[] { 0, 1, 2 };
270
        EnumerableAssert.AreEqual(
271
            Enumerable.Skip(enumerable, 2),
272
            EnumerableSelectManyExtensions.Skip(enumerable, 2));
273

274
        enumerable = new int[] { 0, 1, 1, 1, 2, 2 };
275
        EnumerableAssert.AreEqual(
276
            Enumerable.Skip(enumerable, 0),
277
            EnumerableSelectManyExtensions.Skip(enumerable, 0));
278

279
        enumerable = new int[] { 0, 1, 1, 1, 2, 2 };
280
        EnumerableAssert.AreEqual(
281
            Enumerable.Skip(enumerable, -1),
282
            EnumerableSelectManyExtensions.Skip(enumerable, -1));
283

284
        enumerable = new int[] { 0, 1, 1, 1, 2, 2 };
285
        EnumerableAssert.AreEqual(
286
            Enumerable.Skip(enumerable, 100),
287
            EnumerableSelectManyExtensions.Skip(enumerable, 100));
288

289
        enumerable = new int[] { };
290
        EnumerableAssert.AreEqual(
291
            Enumerable.Skip(enumerable, 100),
292
            EnumerableSelectManyExtensions.Skip(enumerable, 100));
293
    }
294

295
    [TestMethod()]
296
    public void SkipWhileTest()
297
    {
298
        int[] enumerable = new int[] { 0, 1, 2 };
299
        EnumerableAssert.AreEqual(
300
            Enumerable.SkipWhile(enumerable, x => x > 0),
301
            EnumerableSelectManyExtensions.SkipWhile(enumerable, x => x > 0));
302

303
        enumerable = new int[] { 2, 1, 0, -1 };
304
        EnumerableAssert.AreEqual(
305
            Enumerable.SkipWhile(enumerable, x => x > 0),
306
            EnumerableSelectManyExtensions.SkipWhile(enumerable, x => x > 0));
307

308
        enumerable = new int[] { };
309
        EnumerableAssert.AreEqual(
310
            Enumerable.SkipWhile(enumerable, x => x > 0),
311
            EnumerableSelectManyExtensions.SkipWhile(enumerable, x => x > 0));
312
    }
313

314
    [TestMethod()]
315
    public void TakeTest()
316
    {
317
        int[] enumerable = new int[] { 0, 1, 2 };
318
        EnumerableAssert.AreEqual(
319
            Enumerable.Take(enumerable, 2),
320
            EnumerableSelectManyExtensions.Take(enumerable, 2));
321

322
        enumerable = new int[] { 0, 1, 1, 1, 2, 2 };
323
        EnumerableAssert.AreEqual(
324
            Enumerable.Take(enumerable, 0),
325
            EnumerableSelectManyExtensions.Take(enumerable, 0));
326

327
        enumerable = new int[] { 0, 1, 1, 1, 2, 2 };
328
        EnumerableAssert.AreEqual(
329
            Enumerable.Take(enumerable, -1),
330
            EnumerableSelectManyExtensions.Take(enumerable, -1));
331

332
        enumerable = new int[] { 0, 1, 1, 1, 2, 2 };
333
        EnumerableAssert.AreEqual(
334
            Enumerable.Take(enumerable, 100),
335
            EnumerableSelectManyExtensions.Take(enumerable, 100));
336

337
        enumerable = new int[] { };
338
        EnumerableAssert.AreEqual(
339
            Enumerable.Take(enumerable, 100),
340
            EnumerableSelectManyExtensions.Take(enumerable, 100));
341
    }
342

343
    [TestMethod()]
344
    public void TakeWhileTest()
345
    {
346
        int[] enumerable = new int[] { 0, 1, 2 };
347
        EnumerableAssert.AreEqual(
348
            Enumerable.TakeWhile(enumerable, x => x > 0),
349
            EnumerableSelectManyExtensions.TakeWhile(enumerable, x => x > 0));
350

351
        enumerable = new int[] { 2, 1, 0, -1 };
352
        EnumerableAssert.AreEqual(
353
            Enumerable.TakeWhile(enumerable, x => x > 0),
354
            EnumerableSelectManyExtensions.TakeWhile(enumerable, x => x > 0));
355

356
        enumerable = new int[] { };
357
        EnumerableAssert.AreEqual(
358
            Enumerable.TakeWhile(enumerable, x => x > 0),
359
            EnumerableSelectManyExtensions.TakeWhile(enumerable, x => x > 0));
360
    }
361

362
    [TestMethod()]
363
    public void UnionTest()
364
    {
365
        int[] first = new int[] { 0, 1, 2 };
366
        int[] second = new int[] { 3, 4, 5 };
367
        EnumerableAssert.AreEqual(
368
            Enumerable.Union(first, second),
369
            EnumerableSelectManyExtensions.Union(first, second, EqualityComparer<int>.Default));
370

371
        first = new int[] { 0, 1, 2 };
372
        second = new int[] { };
373
        EnumerableAssert.AreEqual(
374
            Enumerable.Union(first, second),
375
            EnumerableSelectManyExtensions.Union(first, second, EqualityComparer<int>.Default));
376

377
        first = new int[] { };
378
        second = new int[] { 3, 4, 5 };
379
        EnumerableAssert.AreEqual(
380
            Enumerable.Union(first, second),
381
            EnumerableSelectManyExtensions.Union(first, second, EqualityComparer<int>.Default));
382

383
        first = new int[] { 0, 1, 2 };
384
        second = new int[] { 2, 3, 4 };
385
        EnumerableAssert.AreEqual(
386
            Enumerable.Union(first, second),
387
            EnumerableSelectManyExtensions.Union(first, second, EqualityComparer<int>.Default));
388
    }
389

390
    [TestMethod()]
391
    public void WhereTest()
392
    {
393
        int[] enumerable = new int[] { 0, 1, 2 };
394
        EnumerableAssert.AreEqual(
395
            Enumerable.Where(enumerable, x => x > 0),
396
            EnumerableSelectManyExtensions.Where(enumerable, x => x > 0));
397

398
        enumerable = new int[] { };
399
        EnumerableAssert.AreEqual(
400
            Enumerable.Where(enumerable, x => x > 0),
401
            EnumerableSelectManyExtensions.Where(enumerable, x => x > 0));
402
    }
403

404
    [TestMethod()]
405
    public void ZipTest()
406
    {
407
        int[] first = new int[] { 0, 1, 2 };
408
        int[] second = new int[] { 3, 4, 5 };
409
        EnumerableAssert.AreEqual(
410
            Enumerable.Zip(first, second, (x, y) => x * y),
411
            EnumerableSelectManyExtensions.Zip(first, second, (x, y) => x * y));
412

413
        first = new int[] { 0, 1, 2 };
414
        second = new int[] { };
415
        EnumerableAssert.AreEqual(
416
            Enumerable.Zip(first, second, (x, y) => x * y),
417
            EnumerableSelectManyExtensions.Zip(first, second, (x, y) => x * y));
418

419
        first = new int[] { };
420
        second = new int[] { 3, 4, 5 };
421
        EnumerableAssert.AreEqual(
422
            Enumerable.Zip(first, second, (x, y) => x * y),
423
            EnumerableSelectManyExtensions.Zip(first, second, (x, y) => x * y));
424

425
        first = new int[] { 0, 1, 2 };
426
        second = new int[] { 2, 3, 4 };
427
        EnumerableAssert.AreEqual(
428
            Enumerable.Zip(first, second, (x, y) => x * y),
429
            EnumerableSelectManyExtensions.Zip(first, second, (x, y) => x * y));
430

431
        first = new int[] { 0, 1 };
432
        second = new int[] { 2, 3, 4 };
433
        EnumerableAssert.AreEqual(
434
            Enumerable.Zip(first, second, (x, y) => x * y),
435
            EnumerableSelectManyExtensions.Zip(first, second, (x, y) => x * y));
436

437
        first = new int[] { 0, 1, 2 };
438
        second = new int[] { 2, 3 };
439
        EnumerableAssert.AreEqual(
440
            Enumerable.Zip(first, second, (x, y) => x * y),
441
            EnumerableSelectManyExtensions.Zip(first, second, (x, y) => x * y));
442
    }
443
}