 
 class __ {
 
-    class func each <ItemType>(list: ItemType[], iterator: ItemType -> Any)  {
+    class func each <T>(list: T[], iterator: T -> Any)  {
         list.map { iterator($0) }
     }
     
     // alias for each
-    class func forEach <ItemType>(list: ItemType[], iterator: ItemType -> Any) {
+    class func forEach <T>(list: T[], iterator: T -> Any) {
         self.each(list, iterator: iterator)
     }
     
-    class func map <ItemType, resultType>(list: ItemType[], iterator: ItemType -> resultType) -> resultType[] {
+    class func map <T, U>(list: T[], iterator: T -> U) -> U[] {
         return list.map { iterator($0) }
     }
     
     // alias for map
-    class func collect <ItemType, resultType>(list: ItemType[], iterator: ItemType -> resultType) -> resultType[] {
+    class func collect <T, U>(list: T[], iterator: T -> U) -> U[] {
         return self.map(list, iterator: iterator)
     }
     
-    class func reduce <ItemType, ResultType>(list: ItemType[], memo: ResultType, iterator: (first:ResultType, second:ItemType) -> ResultType) -> ResultType {
+    class func reduce <T, U>(list: T[], memo: U, iterator: (first:U, second:T) -> U) -> U {
         
         var result = memo
         

    }
    
    // alias for reduce
    class func inject <ItemType, ResultType>(list: ItemType[], memo: ResultType, iterator: (first:ResultType, second:ItemType) -> ResultType) -> ResultType {
        return self.reduce(list, memo: memo, iterator: iterator)
    }
    
    // alias for reduce
    class func foldl <ItemType, ResultType>(list: ItemType[], memo: ResultType, iterator: (first:ResultType, second:ItemType) -> ResultType) -> ResultType {
        return self.reduce(list, memo: memo, iterator: iterator)
    }
    
    class func find <ItemType>(list: ItemType[], filter: ItemType -> Bool) -> ItemType? {
        for item in list {
            if filter(item) {
                return item

        return result
    }
    
    class func indexBy<K, V>(list: Array< Dictionary<K, V> >, key: K) -> Dictionary<V, Dictionary<K,V> > {
        var result = Dictionary<V, Dictionary<K,V> >()
        for item in list {
            result[item[key]!] = item
        }
        return result
    }
    
    class func countBy<T, U>(list: T[], iterator: T -> U) -> Dictionary<U, Int> {
        var result = Dictionary<U, Int>()
        for item in list {
            if let count = result[iterator(item)] {
                result[iterator(item)] = count + 1
