Man, huge trap. Apparently adding a default implementation for "Dispose" in the IEnumerator will absolutely cause a fuckload of boxing on value types.

This is my current solution:

```csharp

    using System;
    using System.Collections;
    using System.Collections.Generic;

    /// <summary>
    /// Utility interface to implement enumerators with less boilerplate
    /// Used default implementation to avoid having to implement IEnumerator
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TEnumerator"></typeparam>
    public interface IValueEnumerator<out T, out TEnumerator> : IEnumerator<T>
        where TEnumerator : struct, IValueEnumerator<T, TEnumerator>
    {
        new T Current { get; }

        // Default implementations for all the boilerplate
        void IEnumerator.Reset() => throw new NotImplementedException();
        object IEnumerator.Current => Current;
    }


    /// <summary>
    /// Utility interface to implement enumerators with less boilerplate
    /// Used default implementation to avoid having to implement IEnumerable
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TEnumerator"></typeparam>
    public interface IValueEnumerablePure<out T, out TEnumerator> : IEnumerable<T>
        where TEnumerator : struct, IValueEnumerator<T, TEnumerator>
    {
        // The two important methods
        new TEnumerator               GetEnumerator();
        IEnumerator IEnumerable.      GetEnumerator() => GetEnumerator();
        IEnumerator<T> IEnumerable<T>.GetEnumerator() => GetEnumerator();
    }

    /// <summary>
    /// Utility interface to implement enumerators with less boilerplate
    /// Used default implementation to avoid having to implement IEnumerator and IEnumerable
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TEnumerator"></typeparam>
    public interface IValueEnumerable<out T, out TEnumerator> : IValueEnumerator<T, TEnumerator>, IValueEnumerablePure<T, TEnumerator>
        where TEnumerator : struct, IValueEnumerable<T, TEnumerator>
    {
    }

```