(edited) ?? => @headius :

Does something like that looks like something sensible:

```ruby
# frozen_string_literal: true

module Biz
  module Periods
    class Linear < SimpleDelegator

      class PrivateEnumerator
        def initialize(periods, shifts, selector)
          @periods   = periods
          @shifts    = shifts
          @selector  = selector
          @sequences = [ @periods, @shifts ]
          @inner_repr = Enumerator.new
        end


        def to_a
          loop do @periods.next rescue StopIteration end
          loop do @shifts.next rescue StopIteration end

          @inner_repr.to_a
        end

        def method_missing(m, *args, &block)
          @inner_repr.send(m, args, block)
        end
      end

      def initialize(periods, shifts, selector)
        @periods   = periods
        @shifts    = shifts
        @selector  = selector
        @sequences = [@periods, @shifts]

        super(linear_periods)
      end

      private

      attr_reader :periods,
                  :shifts,
                  :selector,
                  :sequences

      def linear_periods
        PrivateEnumerator.new do |yielder|
          loop do
            periods.next and next if periods.peek.date == shifts.peek.date

            yielder << begin
              sequences
                .public_send(selector) { |sequence| sequence.peek.date }
                .next
            end
          end

          loop do yielder << periods.next end
        end
      end

    end
  end
end
```