Extending Array to check if it is sorted in Swift?

<blink>
Adaptation, a [solution][1] that will work in Swift 4
[1]:

[To see links please register here]

</blink>

extension Array where Iterator.Element: Comparable {
func isSorted(isOrderedBefore: (Iterator.Element, Iterator.Element) -> Bool) -> Bool {
for i in 1 ..< self.count {
if isOrderedBefore(self[i], self[i-1]) {
return false
}
}
return true
}
}

The most flexible solution to me is a combination of NSAddict's and Wes Campaigne's answer. I.e. combine the advantage of being able to extend protocols and to pass comparator functions as arguments. This eliminates the restrictions both to use it only with arrays and to constrain it to elements conforming to `Comparable` protocol.

extension CollectionType
{
func isSorted(isOrderedBefore: (Generator.Element, Generator.Element) -> Bool) -> Bool
{
var previousIndex = startIndex
var currentIndex = startIndex.successor()

while currentIndex != endIndex
{
if isOrderedBefore(self[previousIndex], self[currentIndex]) == false
{
return false
}

previousIndex = currentIndex
currentIndex = currentIndex.successor()
}

return true
}
}

This can be used on any `Collection` type and sorting criteria can be defined according to your needs.

In Swift 2.0 you can now extend protocols!

extension CollectionType where Generator.Element: Comparable {

public var isSorted: Bool {

var previousIndex = startIndex
var currentIndex = startIndex.successor()

while currentIndex != endIndex {

if self[previousIndex] > self[currentIndex] {
return false
}

previousIndex = currentIndex
currentIndex = currentIndex.successor()
}

return true
}

}

[1, 2, 3, 4].isSorted // true
["a", "b", "c", "e"].isSorted // true
["b", "a", "c", "e"].isSorted // false
[/* Anything not implementing `Comparable` */].isSorted // <~~ Type-error


Note that because we're using `Indexable.Index` instead of a simple `Int` as an index we have to use a while-loop instead, which looks a bit less pretty and clear.

The alternative solution to a free function is to do what Swift's built-in `Array.sort` and `Array.sorted` methods do, and require that you pass a suitable comparator to the method:

extension Array {
func isSorted(isOrderedBefore: (T, T) -> Bool) -> Bool {
for i in 1..<self.count {
if !isOrderedBefore(self[i-1], self[i]) {
return false
}
}
return true
}
}

[1, 5, 3].isSorted(<) // false
[1, 5, 10].isSorted(<) // true
[3.5, 2.1, -5.4].isSorted(>) // true