 
 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 contains
    class func include <ItemType: Equatable>(list: ItemType[], value: ItemType) -> Bool {
        return self.contains(list, value: value);
    }
    
    class func pluck<KeyType: Equatable, ValueType>(list: Array<Dictionary<KeyType, ValueType>>, key: KeyType) -> ValueType[] {
        var result = ValueType[]()
        for item in list {
            if let value = item[key] {
                result += value

    }
    
    // alias for find
    class func detect <T>(list: T[], filter: T -> Bool) -> T? {
        return self.find(list, filter: filter)
    }
    
    
    class func filter <T>(list: T[], filter: T -> Bool) -> T[] {
        var result = T[]()
        for item in list {
            if filter(item) {
                result += item
