change productspace show

Author: Jutho

src/spaces/productspace.jl

@@ -5,22 +5,22 @@ A `ProductSpace` is a tensor product space of `N` vector spaces of type
 `S<:ElementarySpace`. Only tensor products between [`ElementarySpace`](@ref) objects of the
 same type are allowed.
 """
-struct ProductSpace{S<:ElementarySpace,N} <: CompositeSpace{S}
-    spaces::NTuple{N,S}
-    ProductSpace{S,N}(spaces::NTuple{N,S}) where {S<:ElementarySpace,N} = new{S,N}(spaces)
+struct ProductSpace{S <: ElementarySpace, N} <: CompositeSpace{S}
+    spaces::NTuple{N, S}
+    ProductSpace{S, N}(spaces::NTuple{N, S}) where {S <: ElementarySpace, N} = new{S, N}(spaces)
 end
 
-function ProductSpace{S,N}(spaces::Vararg{S,N}) where {S<:ElementarySpace,N}
-    return ProductSpace{S,N}(spaces)
+function ProductSpace{S, N}(spaces::Vararg{S, N}) where {S <: ElementarySpace, N}
+    return ProductSpace{S, N}(spaces)
 end
 
-function ProductSpace{S}(spaces::Tuple{Vararg{S}}) where {S<:ElementarySpace}
-    return ProductSpace{S,length(spaces)}(spaces)
+function ProductSpace{S}(spaces::Tuple{Vararg{S}}) where {S <: ElementarySpace}
+    return ProductSpace{S, length(spaces)}(spaces)
 end
-ProductSpace{S}(spaces::Vararg{S}) where {S<:ElementarySpace} = ProductSpace{S}(spaces)
+ProductSpace{S}(spaces::Vararg{S}) where {S <: ElementarySpace} = ProductSpace{S}(spaces)
 
-function ProductSpace(spaces::Tuple{S,Vararg{S}}) where {S<:ElementarySpace}
-    return ProductSpace{S,length(spaces)}(spaces)
+function ProductSpace(spaces::Tuple{S, Vararg{S}}) where {S <: ElementarySpace}
+    return ProductSpace{S, length(spaces)}(spaces)
 end
 function ProductSpace(space1::ElementarySpace, rspaces::Vararg{ElementarySpace})
     return ProductSpace((space1, rspaces...))
@@ -29,20 +29,20 @@ end
 ProductSpace(P::ProductSpace) = P
 
 # constructors with conversion behaviour
-function ProductSpace{S,N}(V::Vararg{ElementarySpace,N}) where {S<:ElementarySpace,N}
-    return ProductSpace{S,N}(V)
+function ProductSpace{S, N}(V::Vararg{ElementarySpace, N}) where {S <: ElementarySpace, N}
+    return ProductSpace{S, N}(V)
 end
-function ProductSpace{S}(V::Vararg{ElementarySpace}) where {S<:ElementarySpace}
+function ProductSpace{S}(V::Vararg{ElementarySpace}) where {S <: ElementarySpace}
     return ProductSpace{S}(V)
 end
 
-function ProductSpace{S,N}(V::Tuple{Vararg{ElementarySpace,N}}) where {S<:ElementarySpace,N}
+function ProductSpace{S, N}(V::Tuple{Vararg{ElementarySpace, N}}) where {S <: ElementarySpace, N}
     return ProductSpace{S}(convert.(S, V))
 end
-function ProductSpace{S}(V::Tuple{Vararg{ElementarySpace}}) where {S<:ElementarySpace}
+function ProductSpace{S}(V::Tuple{Vararg{ElementarySpace}}) where {S <: ElementarySpace}
     return ProductSpace{S}(convert.(S, V))
 end
-function ProductSpace(V::Tuple{ElementarySpace,Vararg{ElementarySpace}})
+function ProductSpace(V::Tuple{ElementarySpace, Vararg{ElementarySpace}})
     return ProductSpace(promote(V...))
 end
 
@@ -60,15 +60,15 @@ dim(P::ProductSpace) = prod(dims(P))
 Base.axes(P::ProductSpace) = map(axes, P.spaces)
 Base.axes(P::ProductSpace, n::Int) = axes(P.spaces[n])
 
-dual(P::ProductSpace{<:ElementarySpace,0}) = P
+dual(P::ProductSpace{<:ElementarySpace, 0}) = P
 dual(P::ProductSpace) = ProductSpace(map(dual, reverse(P.spaces)))
 
 # Base.conj(P::ProductSpace) = ProductSpace(map(conj, P.spaces))
 
-function Base.show(io::IO, P::ProductSpace{S}) where {S<:ElementarySpace}
+function Base.show(io::IO, P::ProductSpace{S}) where {S <: ElementarySpace}
     spaces = P.spaces
     if length(spaces) == 0
-        print(io, "ProductSpace{", S, ", 0}")
+        return print(io, "one(", type_repr(S), ")")
     end
     if length(spaces) == 1
         print(io, "ProductSpace")
@@ -89,10 +89,10 @@ Return an iterator over all possible combinations of sectors (represented as an
 `NTuple{N, sectortype(S)}`) that can appear within the tensor product space `P`.
 """
 sectors(P::ProductSpace) = _sectors(P, sectortype(P))
-function _sectors(P::ProductSpace{<:ElementarySpace,N}, ::Type{Trivial}) where {N}
+function _sectors(P::ProductSpace{<:ElementarySpace, N}, ::Type{Trivial}) where {N}
     return OneOrNoneIterator(dim(P) != 0, ntuple(n -> Trivial(), N))
 end
-function _sectors(P::ProductSpace{<:ElementarySpace,N}, ::Type{<:Sector}) where {N}
+function _sectors(P::ProductSpace{<:ElementarySpace, N}, ::Type{<:Sector}) where {N}
     return product(map(sectors, P.spaces)...)
 end
 
@@ -103,8 +103,8 @@ end
 Query whether `P` has a non-zero degeneracy of sector `s`, representing a combination of
 sectors on the individual tensor indices.
 """
-function hassector(V::ProductSpace{<:ElementarySpace,N}, s::NTuple{N}) where {N}
-    return reduce(&, map(hassector, V.spaces, s); init=true)
+function hassector(V::ProductSpace{<:ElementarySpace, N}, s::NTuple{N}) where {N}
+    return reduce(&, map(hassector, V.spaces, s); init = true)
 end
 
 """
@@ -114,7 +114,7 @@ end
 Return the degeneracy dimensions corresponding to a tuple of sectors `s` for each of the
 spaces in the tensor product `P`.
 """
-function dims(P::ProductSpace{<:ElementarySpace,N}, sector::NTuple{N,<:Sector}) where {N}
+function dims(P::ProductSpace{<:ElementarySpace, N}, sector::NTuple{N, <:Sector}) where {N}
     return map(dim, P.spaces, sector)
 end
 
@@ -125,12 +125,14 @@ end
 Return the total degeneracy dimension corresponding to a tuple of sectors for each of the
 spaces in the tensor product, obtained as `prod(dims(P, s))``.
 """
-function dim(P::ProductSpace{<:ElementarySpace,N}, sector::NTuple{N,<:Sector}) where {N}
-    return reduce(*, dims(P, sector); init=1)
+function dim(P::ProductSpace{<:ElementarySpace, N}, sector::NTuple{N, <:Sector}) where {N}
+    return reduce(*, dims(P, sector); init = 1)
 end
 
-function Base.axes(P::ProductSpace{<:ElementarySpace,N},
-                   sectors::NTuple{N,<:Sector}) where {N}
+function Base.axes(
+        P::ProductSpace{<:ElementarySpace, N},
+        sectors::NTuple{N, <:Sector}
+    ) where {N}
     return map(axes, P.spaces, sectors)
 end
 
@@ -141,7 +143,7 @@ Return an iterator over the different unique coupled sector labels, i.e. the dif
 fusion outputs that can be obtained by fusing the sectors present in the different spaces
 that make up the `ProductSpace` instance.
 """
-function blocksectors(P::ProductSpace{S,N}) where {S,N}
+function blocksectors(P::ProductSpace{S, N}) where {S, N}
     I = sectortype(S)
     if I == Trivial
         return OneOrNoneIterator(dim(P) != 0, Trivial())
@@ -172,7 +174,7 @@ Return an iterator over all fusion trees that can be formed by fusing the sector
 in the different spaces that make up the `ProductSpace` instance into the coupled sector
 `blocksector`.
 """
-function fusiontrees(P::ProductSpace{S,N}, blocksector::I) where {S,N,I}
+function fusiontrees(P::ProductSpace{S, N}, blocksector::I) where {S, N, I}
     I == sectortype(S) || throw(SectorMismatch())
     uncoupled = map(sectors, P.spaces)
     isdualflags = map(isdual, P.spaces)
@@ -207,8 +209,10 @@ function blockdim(P::ProductSpace, c::Sector)
     return d
 end
 
-function Base.:(==)(P1::ProductSpace{S,N},
-                    P2::ProductSpace{S,N}) where {S<:ElementarySpace,N}
+function Base.:(==)(
+        P1::ProductSpace{S, N},
+        P2::ProductSpace{S, N}
+    ) where {S <: ElementarySpace, N}
     return (P1.spaces == P2.spaces)
 end
 Base.:(==)(P1::ProductSpace, P2::ProductSpace) = false
@@ -220,7 +224,7 @@ Base.hash(P::ProductSpace{S}, h::UInt) where {S} = hash(P.spaces, hash(S, h))
 #---------------------------------------------
 ⊗(V::ElementarySpace, Vrest::ElementarySpace...) = ProductSpace(V, Vrest...)
 ⊗(P::ProductSpace) = P
-function ⊗(P1::ProductSpace{S}, P2::ProductSpace{S}) where {S<:ElementarySpace}
+function ⊗(P1::ProductSpace{S}, P2::ProductSpace{S}) where {S <: ElementarySpace}
     return ProductSpace{S}(tuple(P1.spaces..., P2.spaces...))
 end
 
@@ -233,17 +237,17 @@ Return a tensor product of zero spaces of type `S`, i.e. this is the unit object
 tensor product operation, such that `V ⊗ one(V) == V`.
 """
 Base.one(V::VectorSpace) = one(typeof(V))
-Base.one(::Type{<:ProductSpace{S}}) where {S<:ElementarySpace} = ProductSpace{S,0}(())
-Base.one(::Type{S}) where {S<:ElementarySpace} = ProductSpace{S,0}(())
+Base.one(::Type{<:ProductSpace{S}}) where {S <: ElementarySpace} = ProductSpace{S, 0}(())
+Base.one(::Type{S}) where {S <: ElementarySpace} = ProductSpace{S, 0}(())
 
-Base.:^(V::ElementarySpace, N::Int) = ProductSpace{typeof(V),N}(ntuple(n -> V, N))
+Base.:^(V::ElementarySpace, N::Int) = ProductSpace{typeof(V), N}(ntuple(n -> V, N))
 Base.:^(V::ProductSpace, N::Int) = ⊗(ntuple(n -> V, N)...)
 function Base.literal_pow(::typeof(^), V::ElementarySpace, p::Val{N}) where {N}
-    return ProductSpace{typeof(V),N}(ntuple(n -> V, p))
+    return ProductSpace{typeof(V), N}(ntuple(n -> V, p))
 end
 
-fuse(P::ProductSpace{S,0}) where {S<:ElementarySpace} = oneunit(S)
-fuse(P::ProductSpace{S}) where {S<:ElementarySpace} = fuse(P.spaces...)
+fuse(P::ProductSpace{S, 0}) where {S <: ElementarySpace} = oneunit(S)
+fuse(P::ProductSpace{S}) where {S <: ElementarySpace} = fuse(P.spaces...)
 
 """
     insertleftunit(P::ProductSpace, i::Int=length(P) + 1; conj=false, dual=false)
@@ -254,8 +258,10 @@ More specifically, adds a left monoidal unit or its dual.
 
 See also [`insertrightunit`](@ref insertrightunit(::ProductSpace, ::Val{i}) where {i}), [`removeunit`](@ref removeunit(::ProductSpace, ::Val{i}) where {i}).
 """
-function insertleftunit(P::ProductSpace, ::Val{i}=Val(length(P) + 1);
-                        conj::Bool=false, dual::Bool=false) where {i}
+function insertleftunit(
+        P::ProductSpace, ::Val{i} = Val(length(P) + 1);
+        conj::Bool = false, dual::Bool = false
+    ) where {i}
     u = oneunit(spacetype(P))
     if dual
         u = TensorKit.dual(u)
@@ -275,8 +281,10 @@ More specifically, adds a right monoidal unit or its dual.
 
 See also [`insertleftunit`](@ref insertleftunit(::ProductSpace, ::Val{i}) where {i}), [`removeunit`](@ref removeunit(::ProductSpace, ::Val{i}) where {i}).
 """
-function insertrightunit(P::ProductSpace, ::Val{i}=Val(length(P));
-                         conj::Bool=false, dual::Bool=false) where {i}
+function insertrightunit(
+        P::ProductSpace, ::Val{i} = Val(length(P));
+        conj::Bool = false, dual::Bool = false
+    ) where {i}
     u = oneunit(spacetype(P))
     if dual
         u = TensorKit.dual(u)
@@ -311,7 +319,7 @@ Base.getindex(P::ProductSpace, n::Integer) = P.spaces[n]
 Base.iterate(P::ProductSpace, args...) = Base.iterate(P.spaces, args...)
 Base.indexed_iterate(P::ProductSpace, args...) = Base.indexed_iterate(P.spaces, args...)
 
-Base.eltype(::Type{<:ProductSpace{S}}) where {S<:ElementarySpace} = S
+Base.eltype(::Type{<:ProductSpace{S}}) where {S <: ElementarySpace} = S
 Base.eltype(P::ProductSpace) = eltype(typeof(P))
 
 Base.IteratorEltype(::Type{<:ProductSpace}) = Base.HasEltype()
@@ -321,13 +329,13 @@ Base.reverse(P::ProductSpace) = ProductSpace(reverse(P.spaces))
 
 # Promotion and conversion
 # ------------------------
-function Base.promote_rule(::Type{S}, ::Type{<:ProductSpace{S}}) where {S<:ElementarySpace}
+function Base.promote_rule(::Type{S}, ::Type{<:ProductSpace{S}}) where {S <: ElementarySpace}
     return ProductSpace{S}
 end
 
 # ProductSpace to ElementarySpace
-Base.convert(::Type{S}, P::ProductSpace{S,0}) where {S<:ElementarySpace} = oneunit(S)
-Base.convert(::Type{S}, P::ProductSpace{S}) where {S<:ElementarySpace} = fuse(P.spaces...)
+Base.convert(::Type{S}, P::ProductSpace{S, 0}) where {S <: ElementarySpace} = oneunit(S)
+Base.convert(::Type{S}, P::ProductSpace{S}) where {S <: ElementarySpace} = fuse(P.spaces...)
 
 # ElementarySpace to ProductSpace
-Base.convert(::Type{<:ProductSpace}, V::S) where {S<:ElementarySpace} = ⊗(V)
+Base.convert(::Type{<:ProductSpace}, V::S) where {S <: ElementarySpace} = ⊗(V)