 
     /// Creates an array of numbers (positive and/or negative) progressing from start up to but not including end.
     ///
-    /// :param: from Start value of range
-    /// :param: through End value of range
-    /// :return: Array of elements based on the sequence that is incremented by 1
+    /// - parameter from: Start value of range
+    /// - parameter through: End value of range
+    /// - returns: Array of elements based on the sequence that is incremented by 1
     public class func range<T: Strideable where T.Stride : IntegerLiteralConvertible>(from startVal: T, through endVal: T) -> [T] {
         return self.range(from: startVal, to: endVal + 1, incrementBy: 1)
     }
 
     /// Creates an array of numbers (positive and/or negative) progressing from start up to but not including end.
     ///
-    /// :param: from Start value of range.
-    /// :param: through End value of range.
-    /// :param: incrementBy Increment sequence by.
-    /// :return: Array of elements based on the sequence.
+    /// - parameter from: Start value of range.
+    /// - parameter through: End value of range.
+    /// - parameter incrementBy: Increment sequence by.
+    /// - returns: Array of elements based on the sequence.
     public class func range<T: Strideable>(from startVal: T, through endVal: T, incrementBy: T.Stride) -> [T] {
         return self.range(from: startVal, to: endVal + 1, incrementBy: incrementBy)
     }
 
     /// Reduce function that will resolve to one value after performing combine function on all elements
     ///
-    /// :param: array The array to source from.
-    /// :param: initial Initial value to seed the reduce function with
-    /// :param: combine Function that will combine the passed value with element in the array
-    /// :return: The result of reducing all of the elements in the array into one value
+    /// - parameter array: The array to source from.
+    /// - parameter initial: Initial value to seed the reduce function with
+    /// - parameter combine: Function that will combine the passed value with element in the array
+    /// - returns: The result of reducing all of the elements in the array into one value
     public class func reduce<U, T>(array: [T], initial: U, combine: (U, T) -> U) -> U {
         return array.reduce(initial, combine: combine)
     }
 
     /// Creates an array of an arbitrary sequence. Especially useful with builtin ranges.
     ///
-    /// :param: seq The sequence to generate from.
-    /// :return: Array of elements generated from the sequence.
+    /// - parameter seq: The sequence to generate from.
+    /// - returns: Array of elements generated from the sequence.
     public class func sequence<S: SequenceType>(seq: S) -> [S.Generator.Element] {
         return Array<S.Generator.Element>(seq)
     }
 
     /// Removes all elements from an array that the callback returns true.
     ///
-    /// :param: array The array to wrap.
-    /// :param: callback Remove elements for which callback returns true.
-    /// :return: Array with elements filtered out.
+    /// - parameter array: The array to wrap.
+    /// - parameter callback: Remove elements for which callback returns true.
+    /// - returns: Array with elements filtered out.
     public class func remove<T>(array: [T], callback: (T) -> Bool) -> [T] {
         return array.filter { !callback($0) }
     }
 
     /// Removes an element from an array.
     ///
-    /// :param: array The array to source from.
-    /// :param: element Element that is to be removed
-    /// :return: Array with element removed.
+    /// - parameter array: The array to source from.
+    /// - parameter element: Element that is to be removed
+    /// - returns: Array with element removed.
     public class func remove<T: Equatable>(array: [T], value: T) -> [T] {
         return self.remove(array, callback: {$0 == value})
     }
 
     /// The opposite of initial this method gets all but the first element or first n elements of an array.
     ///
-    /// :param: array The array to source from.
-    /// :param: numElements The number of elements to exclude from the beginning.
-    /// :return: The rest of the elements.
+    /// - parameter array: The array to source from.
+    /// - parameter numElements: The number of elements to exclude from the beginning.
+    /// - returns: The rest of the elements.
     public class func rest<T>(array: [T], numElements: Int = 1) -> [T] {
         var result: [T] = []
         if numElements < array.count && numElements >= 0 {


    /// A no-operation function.
    ///
    /// :return: nil.
    public class func noop() -> () {
    }

    /// Gets the number of seconds that have elapsed since the Unix epoch (1 January 1970 00:00:00 UTC).
    ///
    /// :return: number of seconds as double
    public class func now() -> NSTimeInterval {
        return NSDate().timeIntervalSince1970
    }

    /// Creates a shallow clone of a dictionary excluding the specified keys.
    ///
    /// :param: dictionary The dictionary to source from.
    /// :param: keys The keys to omit from returning dictionary.
    /// :return: Dictionary with the keys specified omitted.
    public class func omit<T, U>(dictionary: [T: U], keys: T...) -> [T: U] {
        var result: [T: U] = [T: U]()



    /// GCD function return greatest common denominator
    ///
    /// - parameter first: number
    /// - parameter second: number
    /// - returns: Greatest common denominator
    public class func gcd(first: Int, _ second: Int) -> Int {
        var first = first
        var second = second
