[stdlib][NFC] Simplify partition(by:)’s implementation

[lorentey]

Getting rid of the labeled breaks makes things a little easier to follow for me.

[lorentey]

@swift-ci test

[NevinBR]

I think the implementation can be simplified further, so it only has two loops instead of three:

var lo = startIndex
var hi = endIndex

while lo < hi {
  if try belongsInSecondPartition(self[lo]) {
    repeat {
      formIndex(before: &hi)
      guard lo < hi else { return lo }
    } while try belongsInSecondPartition(self[hi])
    
    swapAt(lo, hi)
  }
  
  formIndex(after: &lo)
}

return lo

Edit:

Or perhaps even simpler with only one loop:

var lo = startIndex
var hi = endIndex

while lo < hi {
  if try belongsInSecondPartition(self[lo]) {
    hi = try self[lo..<hi].lastIndex{ try !belongsInSecondPartition($0) } ?? lo
    if hi == lo { return lo }
    swapAt(lo, hi)
  }
  formIndex(after: &lo)
}

return lo

[lorentey]

I like the way the original follows easily understandable steps; it also matches the way Hoare originally described this algorithm.

Reducing the number of loops does not seem to increase readability for me; in fact, I find it's quite the opposite.

[NevinBR]

Perhaps it’s just a personal preference, but I find the one-loop version significantly easier to understand than the three-loop version. So much so that the explanatory comments struck me as unnecessary and redundant, so I removed them.

Maybe adding some of them back might be to your liking?

var lo = startIndex
var hi = endIndex

while lo < hi {
  // Invariants at this point:
  //
  // * all elements in `startIndex ..< lo` belong in the first partition
  // * all elements in `hi ..< endIndex` belong in the second partition

  if try belongsInSecondPartition(self[lo]) {
    
    // Find next element down from `hi` that we can swap `lo` with.
    hi = try self[lo..<hi].lastIndex {
      try !belongsInSecondPartition($0)
    } ?? lo
    
    if hi == lo { return lo }
    swapAt(lo, hi)
  }
  
  formIndex(after: &lo)
}

return lo

---

it also matches the way Hoare originally described this algorithm.

I do not see any sample code in the article you linked.

The written prose description of the algorithm in the article matches the one-loop version just as well as the three-loop version, as of course it must since both implementations do the same thing.

[lorentey]

FWIW, I still find my boring version easier to follow; there is also a symmetry to it that is lost in the two-loop lastIndex(where:) variant.

To be fair, I find both of these to be more accessible than the original one with the goto statements. ¯_(ツ)_/¯