     }
     
     // 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

    }

    // alias for filter
    class func select <ItemType>(list: ItemType[], filter: ItemType -> Bool) -> ItemType[] {
        return self.filter(list, filter: filter)
    }
    
    class func reject<ItemType>(list: ItemType[], filter: ItemType -> Bool) -> ItemType[] {
        
        // I tried to compose ! and filter directly
        // but I have no idea do it exactly

        func notFilter(item: ItemType) -> Bool {
            return !filter(item)
        }
        

        return self.map(random, iterator: {index in list[index]})
    }
    
    class func sample<T>(list: T[]) -> T {
        let index = Int(arc4random() % UInt32(list.count))
        return list[index]
    }
    
    class func sample<T>(list: T[], n:Int) -> T[] {
        var result = T[]()
        let random = self.shuffle(Array(0..list.count))
        for i in 0..n {
            result += list[random[i]]
