--- a/src/LazyTensors/tensor_mapping.jl	Fri Mar 18 20:44:17 2022 +0100
+++ b/src/LazyTensors/tensor_mapping.jl	Fri Mar 18 21:14:47 2022 +0100
@@ -1,69 +1,69 @@
-export TensorMapping
+export LazyTensor
 export apply
 export apply_transpose
 export range_dim, domain_dim
 export range_size, domain_size
 
 """
-    TensorMapping{T,R,D}
+    LazyTensor{T,R,D}
 
 Describes a mapping of a `D` dimension tensor to an `R` dimension tensor.
 The action of the mapping is implemented through the method
 ```julia
-    apply(t::TensorMapping{T,R,D}, v::AbstractArray{<:Any,D}, I::Vararg) where {R,D,T}
+    apply(t::LazyTensor{T,R,D}, v::AbstractArray{<:Any,D}, I::Vararg) where {R,D,T}
 ```
 
 The size of the range and domain that the operator works with should be returned by
 the functions
 ```julia
-    range_size(::TensorMapping)
-    domain_size(::TensorMapping)
+    range_size(::LazyTensor)
+    domain_size(::LazyTensor)
 ```
 to allow querying for one or the other.
 
 Optionally the action of the transpose may be defined through
 ```julia
-    apply_transpose(t::TensorMapping{T,R,D}, v::AbstractArray{T,D}, I::Vararg) where {R,D,T}
+    apply_transpose(t::LazyTensor{T,R,D}, v::AbstractArray{T,D}, I::Vararg) where {R,D,T}
 ```
 """
-abstract type TensorMapping{T,R,D} end
+abstract type LazyTensor{T,R,D} end
 
 """
-    apply(t::TensorMapping{T,R,D}, v::AbstractArray{<:Any,D}, I::Vararg) where {R,D,T}
+    apply(t::LazyTensor{T,R,D}, v::AbstractArray{<:Any,D}, I::Vararg) where {R,D,T}
 
 Return the result of the mapping for a given index.
 """
 function apply end
 
 """
-    apply_transpose(t::TensorMapping{T,R,D}, v::AbstractArray{<:Any,R}, I::Vararg) where {R,D,T}
+    apply_transpose(t::LazyTensor{T,R,D}, v::AbstractArray{<:Any,R}, I::Vararg) where {R,D,T}
 
 Return the result of the transposed mapping for a given index.
 """
 function apply_transpose end
 
 """
-    range_dim(::TensorMapping)
+    range_dim(::LazyTensor)
 Return the dimension of the range space of a given mapping
 """
-range_dim(::TensorMapping{T,R,D}) where {T,R,D} = R
+range_dim(::LazyTensor{T,R,D}) where {T,R,D} = R
 
 """
-    domain_dim(::TensorMapping)
+    domain_dim(::LazyTensor)
 Return the dimension of the domain space of a given mapping
 """
-domain_dim(::TensorMapping{T,R,D}) where {T,R,D} = D
+domain_dim(::LazyTensor{T,R,D}) where {T,R,D} = D
 
 
 """
-    range_size(M::TensorMapping)
+    range_size(M::LazyTensor)
 
 Return the range size for the mapping.
 """
 function range_size end
 
 """
-    domain_size(M::TensorMapping)
+    domain_size(M::LazyTensor)
 
 Return the domain size for the mapping.
 """
@@ -71,10 +71,10 @@
 
 
 """
-    eltype(::TensorMapping{T})
+    eltype(::LazyTensor{T})
 
-The type of elements the TensorMapping acts on.
+The type of elements the LazyTensor acts on.
 """
-Base.eltype(::TensorMapping{T}) where T = T
+Base.eltype(::LazyTensor{T}) where T = T
 
 # TODO: Think about boundschecking!