Group and sort an array in Swift

This might seem like overkill but it's the solution that entered my mind.

extension Array {
    /**
    Indicates whether there are any elements in self that satisfy the predicate.
    If no predicate is supplied, indicates whether there are any elements in self.
    */
    func any(predicate: T -> Bool = { t in true }) -> Bool {
        for element in self {
            if predicate(element) {
                return true
            }
        }
        return false
    }

    /**
    Takes an equality comparer and returns a new array containing all the distinct elements.
    */
    func distinct(comparer: (T, T) -> Bool) -> [T] {
        var result = [T]()
        for t in self {
            // if there are no elements in the result set equal to this element, add it
            if !result.any(predicate: { comparer($0, t) }) {
                result.append(t)
            }
        }
        return result
    }
}

let result = currentStat.statEvents
    .map({ $0.name })
    .distinct(==)
    .sorted(>)
    .map({ name in currentStat.statEvents.filter({ $0.name == name }) })

Now you have a list of lists, where the first list is contains all the statEvents of the dinner type, the next list contains the events of the lunch type, etc.

The obvious disadvantage is that this is probably less performant than the other solution. The nice part is that you don't have to rely on parallel arrays in order to get the hours that are associated a particular date.

My take:

extension StatEvents : Comparable {}

func < (lhs:StatEvents, rhs:StatEvents) -> Bool {
    if lhs.name != rhs.name {
        return lhs.name > rhs.name
    } else if lhs.date != rhs.date {
        return lhs.date < rhs.date
    } else {
        return lhs.hours < rhs.hours
    }
}

func == (lhs:StatEvents, rhs:StatEvents) -> Bool {
    return lhs.name == rhs.name
        && lhs.date == rhs.date
        && lhs.hours == rhs.hours
}

struct ResultRow {
    var name: String
    var dates: [String]
    var hours: [Int]
}

var result : [ResultRow] = []

let sorted = currentStat.statEvents.sort()
for event in sorted {
    if result.last?.name != event.name {
        result.append(ResultRow(name: event.name, dates: [], hours: []))
    }
    result[result.endIndex - 1].dates.append(event.date)
    result[result.endIndex - 1].hours.append(event.hours)
}

Test:

for r in result { print(r) }

prints:

p.ResultRow(name: "lunch", dates: ["01-01-2015", "04-01-2015", "07-01-2015"], hours: [1, 4, 7])
p.ResultRow(name: "dinner", dates: ["02-01-2015", "03-01-2015", "05-01-2015"], hours: [2, 3, 5])
p.ResultRow(name: "breakfast", dates: ["06-01-2015", "08-01-2015"], hours: [6, 8])

There are some answers already but what the heck, this is fun. My answer doesn't use a lot of the higher-order functions in Swift, but it gets the job done nevertheless:

// Get the list of unique event names
var eventNames = [String]()
for event in currentStat.statEvents {
    if !eventNames.contains(event.name) {
        eventNames.append(event.name)
    }
}

// The type of the result
struct ResultType {
    var name : String
    var date : [String]
    var hours : [Int]
}

var result = [ResultType]()
for name in eventNames {
    let matchingEvents = currentStat.statEvents.filter { $0.name == name }
    let dates = matchingEvents.map { $0.date }
    let hours = matchingEvents.map { $0.hours }

    result.append(ResultType(name: name, date: dates, hours: hours))
}

The final result is either of type [[String : AnyObject]] or you create a new structtype that holds these values and the result is of type [String : NewStructType]:

struct NewStructType
{ 
    var dates: [String]?
    var hours: [Int]?
}

So you have to decide on that and then you have to write your own function to sort and group your StatEvents-objects. Maybe you can optimize its performance, but here's a first idea how to implement the second version (with NewStructType):

var result = [String : NewStructType]()

for statEvent in currentStat.statEvents
{
    if (result[statEvent.name] != nil)
    {
        var newStructType = result[statEvent.name]!

        newStructType.dates.append(statEvent.date)
        newStructType.hours.append(statEvent.hours)
    }
    else
    {
        result[statEvent.name] = NewStructType(dates: [statEvent.date], hours: [statEvent.hours])
    }
}