fix docstrings

Author: lkdvos

docs/src/lib/tensors.md

@@ -34,7 +34,7 @@ Tensor
 
 A `TensorMap` with undefined data can be constructed by specifying its domain and codomain:
 ```@docs
-TensorMap{T}(::UndefInitializer, V::TensorMapSpace{S,N₁,N₂}) where {T,S,N₁,N₂}
+TensorMap{T}(::UndefInitializer, V::TensorMapSpace)
 ```
 
 The resulting object can then be filled with data using the `setindex!` method as discussed
@@ -45,8 +45,8 @@ in an `@tensor output[...] = ...` expression.
 Alternatively, a `TensorMap` can be constructed by specifying its data, codmain and domain
 in one of the following ways:
 ```@docs
-TensorMap(data::AbstractDict{<:Sector,<:AbstractMatrix}, V::TensorMapSpace{S,N₁,N₂}) where {S,N₁,N₂}
-TensorMap(data::AbstractArray, V::TensorMapSpace{S,N₁,N₂}; tol) where {S<:IndexSpace,N₁,N₂}
+TensorMap(data::AbstractDict{<:Sector,<:AbstractMatrix}, V::TensorMapSpace)
+TensorMap(data::AbstractArray, V::TensorMapSpace; tol)
 ```
 
 Finally, we also support the following `Array`-like constructors

src/tensors/tensor.jl

@@ -87,14 +87,11 @@ const _Tensor{T, A <: DenseVector{T}, S, N} = Tensor{T, S, N, A}
 # - select A and map to _TensorMap{T, A}
 # - select S, N1, N2 and map to TensorMap{T,S,N1,N2,A}
 """
-    TensorMap{T}(undef, codomain::ProductSpace{S,N₁}, domain::ProductSpace{S,N₂}) where {T,S,N₁,N₂}
+    TensorMap{T}(undef, codomain::ProductSpace{S, N₁}, domain::ProductSpace{S, N₂}) where {T, S, N₁, N₂}
     TensorMap{T}(undef, codomain ← domain)
     TensorMap{T}(undef, domain → codomain)
-    # expert mode: select storage type `A`
-    TensorMap{T,S,N₁,N₂,A}(undef, codomain ← domain)
-    TensorMap{T,S,N₁,N₂,A}(undef, domain → domain)
 
-Construct a `TensorMap` with uninitialized data.
+Construct a `TensorMap` with uninitialized data with elements of type `T`.
 """
 TensorMap{T}(::UndefInitializer, V::TensorMapSpace) where {T} =
     _TensorMap{T, _tensormap_storagetype(T)}(undef, V)
@@ -103,6 +100,13 @@ TensorMap{T}(::UndefInitializer, codomain::TensorSpace, domain::TensorSpace) whe
 Tensor{T}(::UndefInitializer, V::TensorSpace) where {T} = TensorMap{T}(undef, V ← one(V))
 
 # specifying storagetype, fill in other parameters
+"""
+    (TensorMap{T, S, N₁, N₂, A} where {S, N₁, N₂})(undef, codomain, domain) where {T, A}
+    (TensorMap{T, S, N₁, N₂, A} where {S, N₁, N₂})(undef, codomain ← domain) where {T, A}
+    (TensorMap{T, S, N₁, N₂, A} where {S, N₁, N₂})(undef, domain → codomain) where {T, A}
+
+Construct a `TensorMap` with uninitialized data stored as `A <: DenseVector{T}`.
+"""
 _TensorMap{T, A}(::UndefInitializer, V::TensorMapSpace) where {T, A} =
     TensorMap{T, spacetype(V), numout(V), numin(V), A}(undef, V)
 _TensorMap{T, A}(::UndefInitializer, codomain::TensorSpace, domain::TensorSpace) where {T, A} =
@@ -126,20 +130,19 @@ _TensorMap{T, A}(data::DenseVector{T}, codomain::TensorSpace, domain::TensorSpac
 const _BlockData{I <: Sector, A <: AbstractMatrix} = AbstractDict{I, A}
 
 """
-    TensorMap(data::AbstractDict{<:Sector,<:AbstractMatrix}, codomain::ProductSpace{S,N₁},
-                domain::ProductSpace{S,N₂}) where {S<:ElementarySpace,N₁,N₂}
+    TensorMap(data::AbstractDict{<:Sector, <:AbstractMatrix}, codomain::ProductSpace, domain::ProductSpace)
     TensorMap(data, codomain ← domain)
     TensorMap(data, domain → codomain)
 
 Construct a `TensorMap` by explicitly specifying its block data.
 
 ## Arguments
-- `data::AbstractDict{<:Sector,<:AbstractMatrix}`: dictionary containing the block data for
+- `data::AbstractDict{<:Sector, <:AbstractMatrix}`: dictionary containing the block data for
   each coupled sector `c` as a matrix of size `(blockdim(codomain, c), blockdim(domain, c))`.
-- `codomain::ProductSpace{S,N₁}`: the codomain as a `ProductSpace` of `N₁` spaces of type
-  `S<:ElementarySpace`.
-- `domain::ProductSpace{S,N₂}`: the domain as a `ProductSpace` of `N₂` spaces of type
-  `S<:ElementarySpace`.
+- `codomain::ProductSpace{S, N₁}`: the codomain as a `ProductSpace` of `N₁` spaces of type
+  `S <: ElementarySpace`.
+- `domain::ProductSpace{S, N₂}`: the domain as a `ProductSpace` of `N₂` spaces of type
+  `S <: ElementarySpace`.
 
 Alternatively, the domain and codomain can be specified by passing a [`HomSpace`](@ref)
 using the syntax `codomain ← domain` or `domain → codomain`.