PeekableEnumerator

[Denis535]

IEnumerator is a sore subject for ,NET programmers when we need to peek next item. So, I write my own PeekableEnumerator and I just want to share it. I hope it will help someone.

PeekableEnumerator.cs
Option.cs

public class PeekableEnumerator<T> : IEnumerator<T>, IDisposable {

    private Option<T> current, next;
    private IEnumerator<T> Source { get; }
    public bool IsStarted { get; private set; }
    public bool IsLast => !PeekInternal().HasValue;
    public bool IsFinished { get; private set; }
    public bool HasNext => PeekInternal().HasValue;
    public Option<T> Current => current;
    public Option<T> Next => PeekInternal();


    public PeekableEnumerator(IEnumerator<T> source!!) {
        Source = source;
    }
    public void Dispose() {
        Source.Dispose();
    }


    // IEnumerator
    T IEnumerator<T>.Current => current.Value;
    object? IEnumerator.Current => current.Value;
    bool IEnumerator.MoveNext() => TakeInternal().HasValue;


    // Take
    public bool TryTake([MaybeNullWhen( false )] out T current) {
        return TakeInternal().TryGetValue( out current );
    }
    public Option<T> Take() {
        return TakeInternal();
    }
    // Peek
    public bool TryPeek([MaybeNullWhen( false )] out T next) {
        return PeekInternal().TryGetValue( out next );
    }
    public Option<T> Peek() {
        return PeekInternal();
    }
    // Reset
    public void Reset() {
        Source.Reset();
        (IsStarted, IsFinished) = (false, false);
        (current, next) = (default, default);
    }


    // Helpers
    private Option<T> TakeInternal() {
        var value = MoveNext( next, Source );
        (IsStarted, IsFinished) = (true, !value.HasValue);
        (current, next) = (value, default);
        return value;
    }
    private Option<T> PeekInternal() {
        // It does not affect IsStarted
        // It does not affect IsFinished
        // It does not affect Current
        var value = MoveNext( next, Source );
        next = value;
        return value;
    }
    private static Option<T> MoveNext(Option<T> next, IEnumerator<T> enumerator) {
        if (next.HasValue) return next;
        if (enumerator.MoveNext()) return enumerator.Current;
        return default;
    }


}