     /// Creates an array of elements split into groups the length of size.
     /// If array can’t be split evenly, the final chunk will be the remaining elements.
     ///
-    /// :param: array to chunk
-    /// :param: size size of each chunk
-    /// :return: array elements chunked
+    /// - parameter array: to chunk
+    /// - parameter size: size of each chunk
+    /// - returns: array elements chunked
     public class func chunk<T>(array: [T], size: Int = 1) -> [[T]] {
         var result = [[T]]()
         var chunk = -1


    /// Initializer of the wrapper object for chaining.
    ///
    /// :param: array The array to wrap.
    public init(_ collection: [C]) {
        self.result = Wrapper(collection)
    }

    /// Get the first object in the wrapper object.
    ///
    /// :return: First element from the array.
    public func first() -> C? {
        return $.first(self.value)
    }

    /// Get the second object in the wrapper object.
    ///
    /// :return: Second element from the array.
    public func second() -> C? {
        return $.second(self.value)
    }

    /// Get the third object in the wrapper object.
    ///
    /// :return: Third element from the array.
    public func third() -> C? {
        return $.third(self.value)
    }

    /// Flattens nested array.
    ///
    /// :return: The wrapper object.
    public func flatten() -> Chain {
        return self.queue {
            return Wrapper($.flatten($0.value))


    /// Creates an array of unique values present in all provided arrays.
    ///
    /// - parameter arrays: The arrays to perform an intersection on.
    /// - returns: Intersection of all arrays passed.
    public class func intersection<T: Hashable>(arrays: [T]...) -> [T] {
        var map: [T: Int] = [T: Int]()
        for arr in arrays {
