     /// i.e.
     ///     A.enclose(2, 0, 5) == ⊂[0 2 5]A
     ///     A.enclose(2, 0, 5) != ⊂[2 0 5]A
-    public func enclose(axes: Int...) -> ComputedArray<ArraySlice<Element>> {
+    public func enclose(axes: Int...) -> ComputedArray<ComputedArray<Element>> {
         return enclose(axes)
     }
     

        guard shape == additionalItems.shape else {
            fatalError("Arrays must have same shape to be interposed")
        }
        
        let newShape = shape + [2] as [Int]
        let items = zip(allElements, additionalItems.allElements).reduce([] as [Element]) { $0 + [$1.0, $1.1] }
        
        return ComputedArray(DenseArray(shape: newShape, baseArray: items))
    }
    
}

            return internalIndices
        }
        
        return ComputedArray(shape: newShape, linear: { ComputedArray(self[internalIndicesList[$0]]) })
    }
    
    /// Reverse the order of Elements along the last axis (columns).
    public func reverse() -> ComputedArray<Element> {
        return self.vectorMap(byRows: true, transform: { $0.reverse() } )
    }
    
    /// Reverse the order of Elements along the first axis.
    public func flip() -> ComputedArray<Element> {
        return self.vectorMap(byRows: false, transform: { $0.reverse() } )
    }
    
    /// Returns a ComputedArray whose dimensions are reversed.
    public func transpose() -> ComputedArray<Element> {
        return ComputedArray(shape: shape.reverse(), cartesian: {indices in
            self[indices.reverse()]
        })
    }
    
    /// Returns a DenseArray with the contents of additionalItems appended to the last axis of the Array.
