 }
 
 extension SequenceType {
+    /**
+     Create a dictionary with the results of applying `transform` to the elements 
+     of `self`, using the first tuple component as the key and the second as the value.
+     
+     Returning `nil` will generate no entry for that element. Returning an existing 
+     key will overwrite previous entries.
+     */
     public func mapToDictionary<Key: Hashable, Value>(@noescape transform: (Self.Generator.Element) -> (Key, Value)?) -> [Key: Value] {
-        
         let elements = flatMap(transform)
         return Dictionary(elements: elements)
     }
     
+    /**
+     Create a dictionary of arrays based on the results of applying `transform` 
+     to the elements of `self`. The first tuple component is used as key and the 
+     second is added into an array containing all results that share the same key, 
+     which is used as the value.
+     
+     Returning `nil` will generate no entry for that element.
+     */
     public func group<Key: Hashable, Value>(@noescape transform: (Self.Generator.Element) -> (Key, Value)?) -> [Key: [Value]] {
         
         let elements = flatMap(transform)

        return minElement(orderedBefore(values))
    }
    
    /// Use the given closures to extract the values for comparison. If the values 
    /// are equal compare using the next closure in the list until they are all exhausted
    public func sort(values: ((Self.Generator.Element, Self.Generator.Element) -> NSComparisonResult)...) -> [Self.Generator.Element] {

        return true
    }
    
    /// Return `true` if the predicate returns `true` for any element in `self`
    public func any(@noescape predicate: (Self.Generator.Element) -> Bool) -> Bool {
        for element in self {
            if predicate(element) { return true }
