Make Raws From a Greed (Generic)

public protocol TwoDimensional {
    associatedtype Measure: SignedNumeric, Comparable
    var xmesure: Measure { get set }
    var ymesure: Measure { get set }
}

/// * (0,3)(1,3)(2,3)(3,3)
/// * (0,2)(1,2)(2,2)(3,2)
/// * (0,1)(1,1)(2,1)(3,1)
/// * (0,0)(1,0)(2,0)(3,0) -> (0,0)(1,0)(2,0)(3,0), (0,1)(1,1)(2,1)(3,1) ...

public func makeRawsFromGreed<C: Collection>(collection: C) -> [C.SubSequence]?
    where
    C.Element: TwoDimensional,
    C.Element: Equatable,
    C.SubSequence: RangeReplaceableCollection {
        guard collection.count > 1 else { return nil }
        let first = collection.first!
        var previousY = first.ymesure
        var corners = [C.Element]()

        for item in collection {
            let currentY = item.ymesure
            if currentY > previousY {
                corners.append(item)
            }
            previousY = currentY
        }

        guard corners.count > 1 else { return nil }

        var rest: C.SubSequence?
        var bunches = [C.SubSequence]()

        for corner in corners {

            let innersplit: [C.SubSequence]

            if let rest = rest {
                innersplit = rest.split(separator: corner, maxSplits: 1)
            } else {
                innersplit = collection.split(separator: corner, maxSplits: 1)
            }

            let bunch = innersplit.first!

            bunches.append(bunch)
            rest = innersplit.last!
        }
        if let rest = rest {
            bunches.append(rest)
        }

        var cornersiterator = corners.makeIterator()
        var outbunches = [C.SubSequence]()
        for bunch in bunches.dropFirst() {
            var workbunch = bunch
            if let nextcorner = cornersiterator.next() {
                workbunch.insert(nextcorner, at: bunch.startIndex)
            }
            outbunches.append(workbunch)
        }

        outbunches.insert(bunches.first!, at: outbunches.startIndex)

        return outbunches
}

// Testing

struct Greeding {
    func test() {

        var vectors = [Vector2D]()
        vectors.append(Vector2D(x: 0, y: 0))
        vectors.append(Vector2D(x: 1, y: 0))
        vectors.append(Vector2D(x: 2, y: 0))
        vectors.append(Vector2D(x: 3, y: 0))

        vectors.append(Vector2D(x: 0, y: 1))
        vectors.append(Vector2D(x: 1, y: 1))
        vectors.append(Vector2D(x: 2, y: 1))
        vectors.append(Vector2D(x: 3, y: 1))

        vectors.append(Vector2D(x: 0, y: 2))
        vectors.append(Vector2D(x: 1, y: 2))
        vectors.append(Vector2D(x: 2, y: 2))
        vectors.append(Vector2D(x: 3, y: 2))

        vectors.append(Vector2D(x: 0, y: 3))
        vectors.append(Vector2D(x: 1, y: 3))
        vectors.append(Vector2D(x: 2, y: 3))
        vectors.append(Vector2D(x: 3, y: 3))

        guard let raws = makeRawsFromGreed(collection: vectors) else { return }
        raws.forEach { print("raw: \($0)") }

    }
}

raw: [[x: 0.0, y: 0.0], [x: 1.0, y: 0.0], [x: 2.0, y: 0.0], [x: 3.0, y: 0.0]]
raw: [[x: 0.0, y: 1.0], [x: 1.0, y: 1.0], [x: 2.0, y: 1.0], [x: 3.0, y: 1.0]]
raw: [[x: 0.0, y: 2.0], [x: 1.0, y: 2.0], [x: 2.0, y: 2.0], [x: 3.0, y: 2.0]]
raw: [[x: 0.0, y: 3.0], [x: 1.0, y: 3.0], [x: 2.0, y: 3.0], [x: 3.0, y: 3.0]]