Add additional Zip and Unzip methods

[TyMick]

Happy Hackoberfest! 😅

I had the desire to unzip one sequence into three in a recent case, so I was wondering, would a three-way Zip and two- and three-way Unzips be worthy additions to EnumerableUtility?

A summary of new methods added:

IEnumerable<TResult> ZipTruncate<T1, T2, TResult>(
	this IEnumerable<T1> first,
	IEnumerable<T2> second,
	Func<T1, T2, TResult> resultSelector);

IEnumerable<(T1, T2, T3)> Zip<T1, T2, T3>(
	this IEnumerable<T1> first,
	IEnumerable<T2> second,
	IEnumerable<T3> third);

IEnumerable<TResult> Zip<T1, T2, T3, TResult>(
	this IEnumerable<T1> first,
	IEnumerable<T2> second,
	IEnumerable<T3> third,
	Func<T1, T2, T3, TResult> resultSelector);

(IEnumerable<T1>, IEnumerable<T2>) Unzip<T1, T2>(this IEnumerable<(T1, T2)> source);

(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>) Unzip<T1, T2, T3>(this IEnumerable<(T1, T2, T3)> source);

(IEnumerable<T1>, IEnumerable<T2>) Unzip<TSource, T1, T2>(
	this IEnumerable<TSource> source,
	Func<TSource, T1> firstSelector,
	Func<TSource, T2> secondSelector);

(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>) Unzip<TSource, T1, T2, T3>(
	this IEnumerable<TSource> source,
	Func<TSource, T1> firstSelector,
	Func<TSource, T2> secondSelector,
	Func<TSource, T3> thirdSelector);

I didn't add a two-way Zip with a resultSelector parameter because one of those was already included in .NET Standard 2.0.

[bgrainger]

Although I can imagine a "lazy" implementation that returns a tuple of two objects that only enumerate the source sequence as they are enumerated, it seems unlikely that we'd build that. I'm wondering whether it would just be worth returning (IReadOnlyList<T1>, IReadOnlyList<T2>) since the sequences will be materialised.

[bgrainger]

Thinking about this more, a lazy implementation could be Unzip(source, firstSelector, secondSelector) => (source.Select(firstSelector), source.Select(secondSelector); I'm wondering if that should just be the implementation, since it adds the benefit of laziness (and just depending on framework code).

[bgrainger]

That does enumerate source twice, which may be undesirable.

[bgrainger]

Overriding my earlier comments: Let's keep the signature (to allow for future laziness) and the current implementation (which enumerates source once).

[TyMick]

Now that you mention it, that gives me an idea: what if we enumerate the source once at the beginning of the method, then return the .Select results as you mentioned? Then half of the process can be lazy, at least.

var enumeratedSource = source.ToArray();
return (enumeratedSource.Select(firstSelector), enumeratedSource.Select(secondSelector));

I've made that change in a1bfb97—let me know if that looks good. 👍🏼

In that case, would it be good to make the source parameter an IReadOnlyCollection instead, to make the required enumeration clearer to the caller? Or is keeping it an IEnumerable worth the flexibility? Maybe we could just add a remark to the doc comment that this enumerates source before the unzipping operation.

[TyMick]

Should I remove these ?? throw new ArgumentNullExceptions since ToArray and Select already throw the same thing for null arguments? Or is it better to add the throw at this level, too?