         return DenseArray(shape: self.shape, baseArray: baseArray)
     }
     
+    /// Maps a `transform` upon a vector of elements from the Array. Either by rows (that is, row vectors of the column-seperated elements) or vectors of first-deminsion-seperated elements.
+    public func vectorMap<A>(byRows rowVector: Bool = true, transform: ([Element]) throws -> [A]) rethrows -> DenseArray<A> {
+        if let s = scalar {
+            return try transform([s]).ravel()
+        }
+        
+        let slice = rowVector ? sequenceFirst : sequenceLast
+        if let first = slice.first where first.isScalar { // Slice is a [ArraySlice<Element>], we need to know if it's constituent Arrays are themselves scalar.
+            return try transform(slice.map { $0.scalar! }).ravel()
+        }
+        
+        let partialResults = try slice.map { try $0.vectorMap(byRows: rowVector, transform: transform) }
+        return rowVector ? DenseArray(collection: partialResults) : DenseArray(collectionOnLastAxis: partialResults)
+    }
+    
     /// Returns a sequence containing pairs of indices and `Element`s.
     public func enumerate() -> AnySequence<([Int], Element)> {
         let indexGenerator = makeRowMajorIndexGenerator(shape)

        return DenseArray(shape: newShape, baseArray: subarrays)
    }
    
    // monadic ⊖
    /// Reverse the order of Elements along the first axis
    public func flip() -> DenseArray<Element> {
        return DenseArray(collection: sequenceFirst.reverse())
    }
    
    // monadic ⌽
    /// Reverse the order of Elements along the last axis (columns)
    public func reverse() -> DenseArray<Element> {
        return DenseArray(collectionOnLastAxis: sequenceLast.reverse()) // Pretty sure one could do this much more efficiently with linear indexing.
    }
    
    // diadic ⊖
    /// Reverse the order of Elements along the first axis
    //    public func rotateFirst(count: Int) -> DenseArray<Element> {
    ////        return DenseArray(collection: sequenceFirst.reverse())
    //    }
    //
    //    // diadic ⌽
    //    /// Reverse the order of Elements along the last axis (columns)
    //    public func rotateLast(count: Int) -> DenseArray<Element> {
    ////        return DenseArray(collectionOnLastAxis: sequenceLast.reverse()) // Pretty sure one could do this much more efficiently with linear indexing.
    //    }
    
    public func transpose() -> DenseArray<Element> {
        let indexGenerator = makeColumnMajorIndexGenerator(shape)
        let transposedSeq = AnySequence(anyGenerator { () -> Element? in

    
}

// MARK: - Map, VectorMap, Enumerate
public extension Array {
    
    /// Maps a `transform` upon each element of the Array returning an Array of the same shape with the results.
