 public extension Tensor where ItemType : Equatable {
 
     public func elementsEqual(_ other: Tensor<ItemType>) -> Bool {
-        return shape.elementsEqual(other.shape) && items.elementsEqual(other.items)
+        return shape.elementsEqual(other.shape) && _items.elementsEqual(other._items)
     }
 
     public func itemsEqual(_ other: Tensor<ItemType>) -> Bool {
-        return items.elementsEqual(other.items)
+        return _items.elementsEqual(other._items)
     }
 
 }

        guard self.shape.contiguousSize == newShape.contiguousSize else {
            return nil
        }
        return Tensor(shape: newShape, items: items)
    }
    
}

                preconditionFailure("I am a scalar and I have no dimensions!")
            }
            return Tensor(shape: elementShape.prepending(bounds.count),
                          items: _items[itemSubrange(fromSubrange: bounds)])
        }
        set {
            guard let elementShape = elementShape else {
                preconditionFailure("I am a scalar and I have no dimensions!")
            }
            precondition(newValue.shape == elementShape, "Element shape mismatch")
            _items[itemSubrange(fromSubrange: bounds)] = newValue._items
        }
    }
    
