     }
     
     // alias for contains
-    class func include <ItemType: Equatable>(list: ItemType[], value: ItemType) -> Bool {
+    class func include <E: Equatable>(list: E[], value: E) -> Bool {
         return self.contains(list, value: value);
     }
     
-    class func pluck<KeyType: Equatable, ValueType>(list: Array<Dictionary<KeyType, ValueType>>, key: KeyType) -> ValueType[] {
-        var result = ValueType[]()
+    class func pluck<K, V>(list: Array<Dictionary<K, V>>, key: K) -> V[] {
+        var result = V[]()
         for item in list {
             if let value = item[key] {
                 result += value

        return result
    }
    
    class func max<ItemType: Comparable>(list: ItemType[]) -> ItemType! {
        return self.tournament(list, comparator: {$0 < $1 } )
    }
    
    class func min<ItemType: Comparable>(list: ItemType[]) -> ItemType! {
        return self.tournament(list, comparator: {$0 > $1 } )
    }
    
    // This function is used in max and min function
    // Since max and min function pass the test, we decide tournament function is work correctly
    class func tournament<ItemType: Comparable>(list: ItemType[], comparator: (ItemType, ItemType) -> Bool) -> ItemType! {
        if list.isEmpty { return nil }
        var candidate = list[0]
        for item in list {

        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
