generic spacetype and sectortype

Author: ogauthe

src/fusiontrees/fusiontrees.jl

@@ -98,7 +98,6 @@ FusionStyle(::Type{<:FusionTree{I}}) where {I<:Sector} = FusionStyle(I)
 BraidingStyle(::Type{<:FusionTree{I}}) where {I<:Sector} = BraidingStyle(I)
 Base.length(::Type{<:FusionTree{<:Sector,N}}) where {N} = N
 
-sectortype(f::FusionTree) = sectortype(typeof(f))
 FusionStyle(f::FusionTree) = FusionStyle(typeof(f))
 BraidingStyle(f::FusionTree) = BraidingStyle(typeof(f))
 Base.length(f::FusionTree) = length(typeof(f))

src/spaces/homspace.jl

@@ -27,13 +27,7 @@ function Base.:(==)(W₁::HomSpace, W₂::HomSpace)
     return (W₁.codomain == W₂.codomain) && (W₁.domain == W₂.domain)
 end
 
-spacetype(W::HomSpace) = spacetype(typeof(W))
-sectortype(W::HomSpace) = sectortype(typeof(W))
-field(W::HomSpace) = field(typeof(W))
-
 spacetype(::Type{<:HomSpace{S}}) where {S} = S
-field(L::Type{<:HomSpace}) = field(spacetype(L))
-sectortype(L::Type{<:HomSpace}) = sectortype(spacetype(L))
 
 numout(W::HomSpace) = length(codomain(W))
 numin(W::HomSpace) = length(domain(W))

src/spaces/vectorspaces.jl

@@ -47,7 +47,6 @@ abstract type VectorSpace end
 Return the field type over which a vector space is defined.
 """
 function field end
-field(V::VectorSpace) = field(typeof(V))
 
 # Basic vector space methods
 #----------------------------
@@ -102,7 +101,6 @@ of a homogeneous tensor product of these spaces.
 abstract type ElementarySpace <: VectorSpace end
 const IndexSpace = ElementarySpace
 
-field(V::ElementarySpace) = field(typeof(V))
 # field(::Type{<:ElementarySpace{𝕜}}) where {𝕜} = 𝕜
 
 @doc """
@@ -274,13 +272,18 @@ abstract type CompositeSpace{S<:ElementarySpace} <: VectorSpace end
 
 InnerProductStyle(::Type{<:CompositeSpace{S}}) where {S} = InnerProductStyle(S)
 
+spacetype(x) = spacetype(typeof(x))
+function spacetype(::Type{T}) where {T}
+    throw(MethodError(spacetype, ("spacetype not defined for type $T",)))
+end
 spacetype(S::Type{<:ElementarySpace}) = S
-spacetype(V::ElementarySpace) = typeof(V) # = spacetype(typeof(V))
 spacetype(::Type{<:CompositeSpace{S}}) where {S} = S
-spacetype(V::CompositeSpace) = spacetype(typeof(V)) # = spacetype(typeof(V))
 
-field(P::Type{<:CompositeSpace}) = field(spacetype(P))
-sectortype(P::Type{<:CompositeSpace}) = sectortype(spacetype(P))
+sectortype(x) = sectortype(typeof(x))
+sectortype(::Type{T}) where {T} = sectortype(spacetype(T))
+
+field(x) = field(typeof(x))
+field(::Type{T}) where {T} = field(spacetype(T))
 
 # make ElementarySpace instances behave similar to ProductSpace instances
 blocksectors(V::ElementarySpace) = collect(sectors(V))

src/tensors/abstracttensor.jl

@@ -190,10 +190,7 @@ end
 
 # tensor characteristics: work on instances and pass to type
 #------------------------------------------------------------
-spacetype(t::AbstractTensorMap) = spacetype(typeof(t))
-sectortype(t::AbstractTensorMap) = sectortype(typeof(t))
 InnerProductStyle(t::AbstractTensorMap) = InnerProductStyle(typeof(t))
-field(t::AbstractTensorMap) = field(typeof(t))
 storagetype(t::AbstractTensorMap) = storagetype(typeof(t))
 blocktype(t::AbstractTensorMap) = blocktype(typeof(t))
 similarstoragetype(t::AbstractTensorMap, T=scalartype(t)) = similarstoragetype(typeof(t), T)