         }
     }
     
+    /**
+    *  Creates a function that executes passed function only after being called n times.
+    *  @param n Number of times after which to call function
+    *  @param function Function to be called that does not take any params
+    *  @return Function that can be called n times after which the callback function is called
+    */
     class func after<T>(n: Int, function: () -> T) -> (() -> T?) {
         let f = self.after(n) { (params: (Any?...)) -> T? in
             return function()

        return result
    }
    
    class func intersection<T : Hashable>(arrays: T[]...) -> T[] {
        var map : Dictionary<T, Int> = Dictionary<T, Int>()
        for arr in arrays {

        return result
    }
    
    /**
    *  Checks if a given value is present in the array.
    *  @param array The array to check against
    *  @param value The value to check
    *  @return Whether value is in the array
    */
    class func contains<T: Equatable>(array: T[], value: T) -> Bool {
        return array.filter({ $0 as? T == value }).count > 0
    }

    /**
    *  Creates an array excluding all values of the provided arrays
    *  @param arrays The arrays to difference from
    *  @return The difference between the first array and all the remaining arrays from the arrays params
    */
    class func difference<T : Hashable>(arrays: T[]...) -> T[] {
        var result : T[] = []
        var map : Dictionary<T, Bool> = Dictionary<T, Bool>()
