public protocol RangeIndexedCollection {

    associatedtype RangeIndex : Comparable
    associatedtype RangeElement

    typealias TaggedRange = (range: Range<RangeIndex>, tag: RangeElement)
    typealias EditBlock = (_ range: Range<RangeIndex>, _ tag: inout RangeElement?)->(RangeElement?)

    mutating func editTags(in range: Range<RangeIndex>, with block: EditBlock)
}

internal protocol RangeIndexedCollection_WithPostProcessing : RangeIndexedCollection {

    typealias PostProcessingBlock = (TaggedRange, (range: Range<RangeIndex>, tag: RangeElement)?) -> (TaggedRange?, removePrecedingRange: Bool)

    mutating func edit(_ editRange: Range<RangeIndex>,
                       withBlock block: EditBlock,
                       postProcessingBlock: PostProcessingBlock?)
}

extension RangeIndexedCollection_WithPostProcessing where RangeElement : Equatable {

    private func merge(range: (range: Range<RangeIndex>, tag: RangeElement), precedingRange: (range: Range<RangeIndex>, tag: RangeElement)) -> (range: Range<RangeIndex>, tag: RangeElement)? {

        guard precedingRange.range.upperBound == range.range.lowerBound else { return nil }

        if range.tag == precedingRange.tag {

            return (precedingRange.range.lowerBound..<range.range.upperBound, range.tag)
        }
        else {

            // Tags not equal
            return nil
        }
    }

    internal mutating func editAndMerge(_ range: Range<RangeIndex>,
                                        withBlock block: EditBlock) {

        edit(range, withBlock: block)
        {
            (editedTaggedRange:TaggedRange, precedingAdjacentRange:TaggedRange?)->(TaggedRange?,Bool) in

            // Try to merge ranges

            if let precedingAdjacentRange = precedingAdjacentRange,
               let mergedTaggedRange      = self.merge(range: editedTaggedRange, precedingRange: precedingAdjacentRange) {

                return (mergedTaggedRange, true)
            }

            return (nil, false)
        }
    }
}