         guard count == baseArray.shape.reduce(1, combine: *) else { fatalError("Reshaped arrays must contain the same number of elements") }
         
         let definition = { index in baseArray[linear: index] }
-        cartesianFn = checkFn(transformFn(definition, stride: stride), shape: shape)
+        cartesianFn = transformFn(definition, stride: stride)
         linearFn = definition
         unified = baseArray.unified
     }
+    
 }
 
 // MARK: - Linear Access

extension ComputedArray {
    
    public subscript(indices: [ArrayIndex]) -> ArraySlice<Element> {
        return ArraySlice(baseArray: self, viewIndices: indices)
    }
    
    public subscript(indices: ArrayIndex...) -> ArraySlice<Element> {
        return ArraySlice(baseArray: self, viewIndices: indices)
    }
    
}

private func checkFn<A>(cartesianFn: [Int] -> A, shape: [Int]) -> [Int] -> A {
    return { indices in
        guard checkBounds(indices, forShape: shape) else { fatalError("Array index out of range") }
        return cartesianFn(indices)
    }
}

private func checkFn<A>(linearFn: Int -> A, count: Int) -> Int -> A {
    return { index in
        guard checkBounds(index, forCount: count) else { fatalError("Array index out of range") }
        return linearFn(index)
    }
}

private func transformFn<A>(cartesianFn: [Int] -> A, stride: [Int]) -> Int -> A {

        stride = calculateStride(shape)
        count = shape.reduce(1, combine: *)
        
        cartesianFn = { _ in repeatedValue }
        linearFn = { _ in repeatedValue }
        unified = true
    }
    
