IsHomogeneous: test all elements of a sequence for equality

[Orace]

I propose for:

(bool? isHomogeneous, T value) IsHomogeneous<T>(this IEnumerable<T> source, IEqualitityComparer<T> comparer = null);

DefaultEqualitityComparer<T> is used if comparer is null.
The return tuple contains:

• isHomogeneous:
  • null if the source is empty
  • true if the source has one element or if all the elements in the source are equals to the first element relatively to comparer
  • false otherwise.
• value: the first value of the source if isHomogeneous is true, default(T) otherwise.

I'm open to give this method any other relevant name.

[Orace]

The overloads can be:

(bool? isHomogeneous, TSource value) IsHomogeneous<TSource>(this IEnumerable<TSource> source);
(bool? isHomogeneous, TSource value) IsHomogeneous<TSource>(this IEnumerable<TSource> source, IEqualitityComparer<TSource> comparer);
(bool? isHomogeneous, TResult value) IsHomogeneous<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector);
(bool? isHomogeneous, TResult value) IsHomogeneous<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector, IEqualitityComparer<TResult> comparer);

[Orace]

An implementation of IsHomogeneous is available in #700:

MoreLINQ/MoreLinq/EquiInterleave.cs

Lines 94 to 110 in 365adcc

	private static (bool? isHomogeneous, T value) IsHomogeneous<T>(this IEnumerable<T> source)
	{
	var comparer = EqualityComparer<T>.Default;
	using var e = source.GetEnumerator();
	if (!e.MoveNext())
	return (null, default);
	var first = e.Current;
	while (e.MoveNext())
	{
	if (!comparer.Equals(first, e.Current))
	return (false, default);
	}
	return (true, first);
	}

[atifaziz]

Sounds like Distinct + TrySingle (#540).

[Orace]

@atifaziz, it is but with O(1) memory usage.

[atifaziz]

Fair point but then thinking HomogeneousOrEmpty would be better? That is, return a sequence of one if all are the same or none. It's more idiomatic.

[atifaziz]

@atifaziz, it is but with O(1) memory usage.

Second thoughts?

[Orace]

@atifaziz, it is but with O(1) memory usage.

Second thoughts?

Yep, distinc + TrySingle doesn't cost that much.

I'm ok with any name proposition.

[Orace]

HomogeneousOrEmpty will not distinct empty from non-homogeneous.

Here an example of use (an overload with selector predicate may be more adapted here):

MoreLINQ/MoreLinq/EquiInterleave.cs

Lines 73 to 86 in 365adcc

	for (;;)
	{
	var (isHomogeneous, hasNext) = enumerators.Select(e => e.MoveNext()).IsHomogeneous();
	if (isHomogeneous == false)
	throw new InvalidOperationException("Input sequences are of different length.");
	if (!hasNext)
	break;
	foreach (var enumerator in enumerators)
	yield return enumerator.Current;
	}
	}

[atifaziz]

Yep, distinc + TrySingle doesn't cost that much.

It doesn't cost if it's homogeneous but could otherwise.

I'm ok with any name proposition.

First the signature then the name. Instead of asking a question or returning a Boolean, return a sequence of one if source is homogenous otherwise abort early and return an empty sequence (yield break). Joining with another sequence (e.g. Zip) would then have the right effect of returning a sequence or none.

HomogeneousOrEmpty will not distinct empty from non-homogeneous.

Sorry, I don't understand.

[Orace]

HomogeneousOrEmpty will not distinct empty from non-homogeneous.

Sorry, I don't understand.

If the sequence is empty my proposal return null
If it's not homogeneous it's return false
HomogeneousOrEmpty return empty in both case, so you can't made a distinction between empty and not-homogeneous

[atifaziz]

Fair point if you are after reduction without an error for an undefined state but then Is… is misleading because there is no Boolean result. You are looking for 3 states that define the homogeneity of a source:

public static TResult Homogeneity<T, TResult>(
    this IEnumerable<T> source,
    TResult ambiguous, TResult heterogeneous, Func<T, TResult> homogeneous)

[Orace]

Indeed it's a 3 state. And this looks like the discussion about TrySingle.

The 3 new parameters really add complexity, in my use case example it's obvious:

var (isHomogeneous, hasNext) = enumerators.Select(e => e.MoveNext()).IsHomogeneous(((bool?)null, default), (false, default), v  => (true, v)); 

And it's source of bug since we can mess up with the two first parameters.
And if we want overloads with a selector and a comparer it became impossible to use.

That's why I prefer a new class or struct as return type with a 3 state enum and the homogeneous value if any.

class HomogeneityResult<T>
{
  public Homogeneity Homogeneity { get; } // empty, homogeneous, heterogeneous
  public T Value { get; }
}

Or with bool properties:

class HomogeneityResult<T>
{
  public bool HasValue { get; }
  public bool IsHomogeneous { get; }
  public T Value { get; }
}