SortOnProperty.swift

struct Person {
    let firstName: String
    let lastName: String
}

let names = """
    Sandy Maynez
    Kelli Ragland
    Tracee Santucci
    Bella Burts
    Ulysses Beal
    Flavia Dare
    Cherri Esters
    Lila Spilman
    Eldora Halliburton
    Nathanial Charlebois
    Mitzi Paladino
    Coletta Stricker
    Danilo Cisneros
    Kandi Hypolite
    Valencia Clifton
    Irwin Burchill
    Kyoko Dewees
    Anisha Mingo
    Patrice Buchwald
    Margery Shippy
    Bob Borror
    Linsey Jacobo
    Janell Pitcock
    Lissa Goodrum
    Drew Meinecke
    Katherin Hamblen
    Alana Bogan
    Florene Derossett
    Youlanda Marinez
    Hortencia Roop
    Isela Cueto
    Daniel Loth
    Suzann Desilets
    Tina Styers
    Karena Greenly
    Ilene Dilworth
    Lasonya Pascale
    Evelyne Horak
    Rufina Ausmus
    Sharleen Pimental
    Jenee Mcclanahan
    Lavon Laney
    Christiane Parchman
    Garrett Krieger
    Alline Hanes
    Mandy Stoneburner
    Rebecca Ormond
    Adrienne Sabourin
    Claudio Mclin
    Georgianna Grand
    """

let people: [Person] = names
    .split(separator: "\n")
    .map { name in
        let parts = name.split(separator: " ")
        return Person(firstName: String(parts[0]), lastName: String(parts[1]))
    }

extension Sequence {
    func naiveSorted<T>(on propertyAccessor: (Element) throws -> T) rethrows -> [Element] where T: Comparable {
        return try sorted { a, b in
            let propA = try propertyAccessor(a)
            let propB = try propertyAccessor(b)
            return propA < propB
        }
    }

    func awesomeSorted<T>(on propertyAccessor: (Element) throws -> T) rethrows -> [Element] where T: Comparable {
        return try self
            .map { element -> (element: Element, property: T) in
                return (element, try propertyAccessor(element))
            }
            .sorted(by: { pair1, pair2 in
                return pair1.property < pair2.property
            })
            .map { pair in
                pair.element
            }
    }

    func awesomeLazySorted<T>(on propertyAccessor: (Element) throws -> T) rethrows -> [Element] where T: Comparable {
        return try self.lazy
            .map { element -> (element: Element, property: T) in
                return (element, try propertyAccessor(element))
            }
            .sorted(by: { pair1, pair2 in
                return pair1.property < pair2.property
            })
            .map { pair in
                pair.element
            }
    }
}

var called = 0
people.naiveSorted(on: { person -> String in
    called += 1
    return person.lastName
})
called // 554 calls, 0 intermediate arrays

called = 0
people.awesomeSorted(on: { person -> String in
    called += 1
    return person.lastName
})
called // 50 calls, 2 intermediate arrays

called = 0
people.awesomeLazySorted(on: { person -> String in
    called += 1
    return person.lastName
})
called // 50 calls, 1 intermediate array