Seems DistinctByIterator much clearer than DistinctIterator, any chance to make DistinctIterator simpler?

[jjshao-ms]

The DistinctByIterator's implementation seems to be much clearer than

runtime/src/libraries/System.Linq/src/System/Linq/Distinct.cs

Lines 62 to 79 in 71a3d36

	private static IEnumerable<TSource> DistinctByIterator<TSource, TKey>(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer)
	{
	using IEnumerator<TSource> enumerator = source.GetEnumerator();
	if (enumerator.MoveNext())
	{
	var set = new HashSet<TKey>(DefaultInternalSetCapacity, comparer);
	do
	{
	TSource element = enumerator.Current;
	if (set.Add(keySelector(element)))
	{
	yield return element;
	}
	}
	while (enumerator.MoveNext());
	}
	}

the DistinctIterator one

runtime/src/libraries/System.Linq/src/System/Linq/Distinct.cs

Lines 85 to 150 in 71a3d36

	private sealed partial class DistinctIterator<TSource> : Iterator<TSource>
	{
	private readonly IEnumerable<TSource> _source;
	private readonly IEqualityComparer<TSource>? _comparer;
	private HashSet<TSource>? _set;
	private IEnumerator<TSource>? _enumerator;
	public DistinctIterator(IEnumerable<TSource> source, IEqualityComparer<TSource>? comparer)
	{
	Debug.Assert(source != null);
	_source = source;
	_comparer = comparer;
	}
	public override Iterator<TSource> Clone() => new DistinctIterator<TSource>(_source, _comparer);
	public override bool MoveNext()
	{
	switch (_state)
	{
	case 1:
	_enumerator = _source.GetEnumerator();
	if (!_enumerator.MoveNext())
	{
	Dispose();
	return false;
	}
	TSource element = _enumerator.Current;
	_set = new HashSet<TSource>(DefaultInternalSetCapacity, _comparer);
	_set.Add(element);
	_current = element;
	_state = 2;
	return true;
	case 2:
	Debug.Assert(_enumerator != null);
	Debug.Assert(_set != null);
	while (_enumerator.MoveNext())
	{
	element = _enumerator.Current;
	if (_set.Add(element))
	{
	_current = element;
	return true;
	}
	}
	break;
	}
	Dispose();
	return false;
	}
	public override void Dispose()
	{
	if (_enumerator != null)
	{
	_enumerator.Dispose();
	_enumerator = null;
	_set = null;
	}
	base.Dispose();
	}
	}

Any chance to make DistinctIterator looks like DistinctByIterator? Or is there any performance/code size related background prevent us from doing so?

[stephentoub]

DistinctIterator is written that way because it allows implementing additional interfaces on the type, something Distinct can take advantage of more so than DistinctBy. You can see how that's utilized in the Distinct.SpeedOpt.cs file.