even more careful

Author: lkdvos

src/tensors/abstracttensor.jl

@@ -65,33 +65,35 @@ appropriate storage types. Additionally this registers the default storage type
 `T <: Number` is provided, which is `Vector{T}`.
 """ similarstoragetype
 
-# implement in type domain and fill in default value
-@inline similarstoragetype(t, ::Type{T} = scalartype(t)) where {T <: Number} =
-    similarstoragetype(typeof(t), T)
+# implement in type domain
+similarstoragetype(t) = similarstoragetype(typeof(t))
+similarstoragetype(t, ::Type{T}) where {T <: Number} = similarstoragetype(typeof(t), T)
+
+# avoid infinite recursion
+similarstoragetype(X::Type) =
+    throw(ArgumentError("Cannot determine a storagetype for tensor / array type `$X`"))
+similarstoragetype(X::Type, ::Type{T}) where {T <: Number} =
+    throw(ArgumentError("Cannot determine a storagetype for tensor / array type `$X` and/or scalar type `$T`"))
 
 # implement on tensors
+similarstoragetype(::Type{TT}) where {TT <: AbstractTensorMap} = similarstoragetype(storagetype(TT))
 similarstoragetype(::Type{TT}, ::Type{T}) where {TT <: AbstractTensorMap, T <: Number} =
     similarstoragetype(storagetype(TT), T)
 
 # implement on arrays
+similarstoragetype(::Type{A}) where {A <: DenseVector{<:Number}} = A
 Base.@assume_effects :foldable similarstoragetype(::Type{A}, ::Type{T}) where {A <: AbstractArray, T <: Number} =
     Core.Compiler.return_type(similar, Tuple{A, Type{T}, Int})
 
-# implement on sectordicts - intercept scalartype defaults!
-similarstoragetype(d::D, ::Type{T} = scalartype(valtype(d))) where {D <: AbstractDict{<:Sector}, T <: Number} =
-    similarstoragetype(typeof(d), T)
-similarstoragetype(::Type{D}, ::Type{T} = scalartype(valtype(D))) where {D <: AbstractDict{<:Sector}, T <: Number} =
+# implement on sectordicts
+similarstoragetype(::Type{D}) where {D <: AbstractDict{<:Sector, <:AbstractMatrix}} =
+    similarstoragetype(valtype(D))
+similarstoragetype(::Type{D}, ::Type{T}) where {D <: AbstractDict{<:Sector, <:AbstractMatrix}, T <: Number} =
     similarstoragetype(valtype(D), T)
 
 # default storage type for numbers
 similarstoragetype(::Type{T}) where {T <: Number} = Vector{T}
 
-# avoid infinite recursion
-similarstoragetype(X::Type, Y::Type) =
-    throw(ArgumentError("Cannot determine a storagetype for tensor / array type `$X` and/or scalar type `$Y`"))
-# ambiguity
-similarstoragetype(X::Type, ::Type{Y}) where {Y <: Number} =
-    throw(ArgumentError("Cannot determine a storagetype for tensor / array type `$X` and/or scalar type `$Y`"))
 
 # tensor characteristics: space and index information
 #-----------------------------------------------------

src/tensors/tensoroperations.jl

@@ -11,12 +11,7 @@ function TO.tensoralloc(
     A = storagetype(TT)
     dim = fusionblockstructure(structure).totaldim
     data = TO.tensoralloc(A, dim, istemp, allocator)
-
-    # the following doesn't work since data isn't actually restricted to <: A
-    # so hardcode type instead
-    # TT′ = tensormaptype(spacetype(structure), numout(structure), numin(structure), typeof(data))
-    TT′ = TensorMap{scalartype(data), spacetype(structure), numout(structure), numin(structure), typeof(data)}
-
+    TT′ = tensormaptype(spacetype(structure), numout(structure), numin(structure), typeof(data))
     return TT′(data, structure)
 end