superpig

public static class LinqExtensions
{
    private class SplitSequenceEnumerator<T> : IEnumerator<IEnumerable<T>>
    {
        private readonly IEnumerable<T> _baseSequence;
        private readonly T[] _separators;
        private IEnumerable<T> _remainingSequence;

        public SplitSequenceEnumerator(IEnumerable<T> baseSequence, T[] separators)
        {
            if(baseSequence == null) throw new ArgumentNullException("baseSequence");
            if(separators == null) separators = new T[0];

            _baseSequence = baseSequence;
            _separators = separators;
            _remainingSequence = null; // Initial state should be such that we're "before" the first elem
        }

        public void Dispose()
        {
            
        }

        public bool MoveNext()
        {
            if(_remainingSequence == null) Reset();
            _remainingSequence.SkipWhile(t => !_separators.Contains(t)).Skip(1);
            return _remainingSequence.Count() > 0;
        }

        public void Reset()
        {
            _remainingSequence = _baseSequence;
        }

        public IEnumerable<T> Current
        {
            get { return _remainingSequence.TakeWhile(t => !_separators.Contains(t)); }
        }

        object IEnumerator.Current
        {
            get { return Current; }
        }
    }

    private class SplitSequence<T> : IEnumerable<IEnumerable<T>>
    {
        private readonly IEnumerable<T> _baseSequence;
        private readonly T[] _separators;

        public SplitSequence(IEnumerable<T> baseSequence, T[] separators)
        {
            _baseSequence = baseSequence;
            _separators = separators;
        }

        public IEnumerator<IEnumerable<T>> GetEnumerator()
        {
            return new SplitSequenceEnumerator<T>(_baseSequence, _separators);
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }

    public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> xs, params T[] separators)
    {
        return new SplitSequence<T>(xs, separators);
    }
}