Rework named-type parameters around a single Named scalar (#173)

## Summary

Reworks the type parameters of the named array and scalar types so the
name leads and every parameter is inferable from the fields, and
collapses the named-integer type hierarchy into a single `Named` scalar.

The named types now read `Named{Name, Denamed}` (the scalar),
`AbstractNamedArray{Name, DenamedT, N} <: AbstractArray{Named{Name,
DenamedT}, N}`, and `AbstractNamedUnitRange{Name, DenamedT<:Integer}`,
with `Name` leading to match `AbstractITensor{DimName}` and the element
type derived as `Named{Name, DenamedT}` rather than carried as a
separate parameter. The concrete `NamedArray`, `NamedUnitRange`, and
`Index` infer all of their parameters from their `value` and `name`
fields.

A single `Named` wrapper replaces `AbstractNamedInteger`, the
`NamedInteger` struct, `IndexVal`, and `NoncontiguousIndex`: a named
integer is `Named{Name, <:Integer}`, an index value is `Named{IndexName,
<:Integer}`, and a non-contiguous index is a `NamedArray` with an
`IndexName` name. `NamedInteger` stays available as a parametric alias,
`const NamedInteger{Name, Denamed<:Integer} = Named{Name, Denamed}`.
Because the wrapper is universal, a `NamedArray` now works for any
element type, where a non-integer `NamedArray` errored before.

Equality and hashing across named array types are type-agnostic,
following Base's array convention (`[1, 2, 3] == 1:3` and they hash
equally): one generic `hash(::AbstractNamedArray)` uses a single shared
tag rather than the concrete type, so `a == b` implies `hash(a) ==
hash(b)`.

Breaking: the type-parameter order and shape change, and the
`AbstractNamedInteger`, `NamedInteger` struct, `IndexVal`, and
`NoncontiguousIndex` names are removed.

Author: mtfishman

ext/ITensorBaseBlockArraysExt/ITensorBaseBlockArraysExt.jl

@@ -1,19 +1,16 @@
 module ITensorBaseBlockArraysExt
 using ArrayLayouts: ArrayLayouts
 using BlockArrays: Block, BlockRange
-using ITensorBase: AbstractITensor, AbstractNamedInteger, AbstractNamedUnitRange,
-    getindex_named, view_nameddims
-
-# The first parameter of `AbstractNamedUnitRange` is its element type, an
-# `AbstractNamedInteger`, which is not an `Integer`. These methods disambiguate
-# named-range block indexing from `BlockArrays`' generic `AbstractArray`
-# block-indexing methods.
-function Base.getindex(r::AbstractNamedUnitRange{<:AbstractNamedInteger}, I::Block{1})
+using ITensorBase: AbstractITensor, AbstractNamedUnitRange, getindex_named, view_nameddims
+
+# These methods disambiguate named-range block indexing from `BlockArrays`' generic
+# `AbstractArray` block-indexing methods.
+function Base.getindex(r::AbstractNamedUnitRange, I::Block{1})
     # TODO: Use `Derive.@interface NamedArrayInterface() r[I]` instead.
     return getindex_named(r, I)
 end
 
-function Base.getindex(r::AbstractNamedUnitRange{<:AbstractNamedInteger}, I::BlockRange{1})
+function Base.getindex(r::AbstractNamedUnitRange, I::BlockRange{1})
     # TODO: Use `Derive.@interface NamedArrayInterface() r[I]` instead.
     return getindex_named(r, I)
 end

src/ITensorBase.jl

@@ -9,8 +9,8 @@ using Compat: @compat
 # Named-array machinery (relocated from NamedDimsArrays.jl).
 include("isnamed.jl")
 include("randname.jl")
-include("abstractnamedinteger.jl")
-include("namedinteger.jl")
+include("name.jl")
+include("named.jl")
 include("abstractnamedarray.jl")
 include("namedarray.jl")
 include("abstractnamedunitrange.jl")

src/abstractitensor.jl

@@ -373,11 +373,11 @@ Base.IndexStyle(s1::IndexStyle, s2::NamedIndexCartesian) = NamedIndexCartesian()
 Base.IndexStyle(s1::NamedIndexCartesian, s2::IndexStyle) = NamedIndexCartesian()
 
 # Like CartesianIndex but with named dimensions.
-struct NamedDimsCartesianIndex{N, Index <: Tuple{Vararg{AbstractNamedInteger, N}}} <:
+struct NamedDimsCartesianIndex{N, Index <: Tuple{Vararg{NamedInteger, N}}} <:
     Base.AbstractCartesianIndex{N}
     I::Index
 end
-NamedDimsCartesianIndex(I::AbstractNamedInteger...) = NamedDimsCartesianIndex(I)
+NamedDimsCartesianIndex(I::NamedInteger...) = NamedDimsCartesianIndex(I)
 Base.Tuple(I::NamedDimsCartesianIndex) = I.I
 function Base.show(io::IO, I::NamedDimsCartesianIndex)
     print(io, "NamedDimsCartesianIndex")
@@ -390,7 +390,7 @@ struct NamedDimsCartesianIndices{
         N,
         DimName,
         Indices <: Tuple{Vararg{AbstractNamedUnitRange, N}},
-        Index <: Tuple{Vararg{AbstractNamedInteger, N}},
+        Index <: Tuple{Vararg{NamedInteger, N}},
     } <: AbstractITensor{DimName}
     indices::Indices
     function NamedDimsCartesianIndices(indices::Tuple{Vararg{AbstractNamedUnitRange}})
@@ -511,7 +511,7 @@ function Base.checkbounds(::Type{Bool}, a::AbstractITensor, I::Int...)
 end
 
 function Base.to_indices(
-        a::AbstractITensor, I::Tuple{AbstractNamedInteger, Vararg{AbstractNamedInteger}}
+        a::AbstractITensor, I::Tuple{NamedInteger, Vararg{NamedInteger}}
     )
     perm = getperm(name.(I), dimnames(a))
     # TODO: Throw a `NameMismatch` error.
@@ -545,7 +545,7 @@ function Base.getindex(a::AbstractITensor, I1::Int, Irest::Int...)
     return getindex(denamed(a), I1, Irest...)
 end
 function Base.getindex(
-        a::AbstractITensor, I1::AbstractNamedInteger, Irest::AbstractNamedInteger...
+        a::AbstractITensor, I1::NamedInteger, Irest::NamedInteger...
     )
     return getindex(a, to_indices(a, (I1, Irest...))...)
 end
@@ -567,8 +567,8 @@ function Base.setindex!(a::AbstractITensor, value, I::CartesianIndex)
 end
 
 function Base.setindex!(
-        a::AbstractITensor, value, I1::AbstractNamedInteger,
-        Irest::AbstractNamedInteger...
+        a::AbstractITensor, value, I1::NamedInteger,
+        Irest::NamedInteger...
     )
     setindex!(a, value, to_indices(a, (I1, Irest...))...)
     return a
@@ -599,7 +599,7 @@ end
 
 # Like `const ViewIndex = Union{Real,AbstractArray}`.
 const NamedViewIndex =
-    Union{AbstractNamedInteger, AbstractNamedUnitRange, AbstractNamedArray}
+    Union{NamedInteger, AbstractNamedUnitRange, AbstractNamedArray}
 
 using ArrayLayouts: ArrayLayouts, MemoryLayout
 
@@ -625,10 +625,10 @@ end
 function Base.getindex(a::AbstractArray, I1::NamedViewIndex, Irest::NamedViewIndex...)
     return copy(view(a, I1, Irest...))
 end
-# Disambiguate from `Base.getindex(A::Array, I::AbstractUnitRange{<:Integer})`.
-# The element type of a named unit range is an `AbstractNamedInteger`, which is not
-# an `Integer`.
-function Base.getindex(a::Array, I1::AbstractNamedUnitRange{<:AbstractNamedInteger})
+# A named unit range is an `AbstractArray`, so for a concrete `Array` the Base
+# `getindex(::Array, ::AbstractVector)` method would otherwise win over the generic
+# named `getindex` above. This restores the named behavior for `Array`.
+function Base.getindex(a::Array, I1::AbstractNamedUnitRange)
     return copy(view(a, I1))
 end
 function Base.view(a::AbstractArray, I1::NamedViewIndex, Irest::NamedViewIndex...)
@@ -803,12 +803,12 @@ for (f, f′) in [(:rand, :_rand), (:randn, :_randn)]
         function Base.$f(
                 rng::AbstractRNG,
                 elt::Type{<:Number},
-                dims::Tuple{AbstractNamedInteger, Vararg{AbstractNamedInteger}}
+                dims::Tuple{NamedInteger, Vararg{NamedInteger}}
             )
             return $f(rng, elt, Base.oneto.(dims))
         end
     end
-    for dimtype in [:AbstractNamedInteger, :AbstractNamedUnitRange]
+    for dimtype in [:NamedInteger, :AbstractNamedUnitRange]
         @eval begin
             function Base.$f(
                     rng::AbstractRNG, elt::Type{<:Number}, dim1::$dimtype,
@@ -827,7 +827,7 @@ for (f, f′) in [(:rand, :_rand), (:randn, :_randn)]
         end
     end
 end
-for f in [:zeros, :ones], dimtype in [:AbstractNamedInteger, :AbstractNamedUnitRange]
+for f in [:zeros, :ones], dimtype in [:NamedInteger, :AbstractNamedUnitRange]
     @eval begin
         function Base.$f(
                 elt::Type{<:Number}, ax::Tuple{$dimtype, Vararg{$dimtype}}
@@ -842,7 +842,7 @@ for f in [:zeros, :ones], dimtype in [:AbstractNamedInteger, :AbstractNamedUnitR
         Base.$f(dim1::$dimtype, dims::Vararg{$dimtype}) = $f((dim1, dims...))
     end
 end
-for dimtype in [:AbstractNamedInteger, :AbstractNamedUnitRange]
+for dimtype in [:NamedInteger, :AbstractNamedUnitRange]
     @eval begin
         function Base.fill(value, ax::Tuple{$dimtype, Vararg{$dimtype}})
             a = fill(value, denamed.(ax))

src/abstractnamedarray.jl

@@ -1,17 +1,18 @@
-using TypeParameterAccessors: unspecify_type_parameters
+# `Name` leads (matching `AbstractITensor{DimName}`); `DenamedT` is the unwrapped
+# element type and `N` the rank. The element type is always `Named{Name, DenamedT}`,
+# so it is hardcoded in the `AbstractArray` supertype rather than carried as a
+# parameter. The wrapped-container type lives only on the concrete subtypes.
+abstract type AbstractNamedArray{Name, DenamedT, N} <:
+AbstractArray{Named{Name, DenamedT}, N} end
 
-abstract type AbstractNamedArray{T, N, Value <: AbstractArray, Name} <: AbstractArray{T, N} end
-
-const AbstractNamedVector{T, Value <: AbstractVector, Name} =
-    AbstractNamedArray{T, 1, Value, Name}
-const AbstractNamedMatrix{T, Value <: AbstractVector, Name} =
-    AbstractNamedArray{T, 2, Value, Name}
+const AbstractNamedVector{Name, DenamedT} = AbstractNamedArray{Name, DenamedT, 1}
+const AbstractNamedMatrix{Name, DenamedT} = AbstractNamedArray{Name, DenamedT, 2}
 
 # Minimal interface.
 denamed(a::AbstractNamedArray) = throw(MethodError(denamed, Tuple{typeof(a)}))
 name(a::AbstractNamedArray) = throw(MethodError(name, Tuple{typeof(a)}))
 
-# This can be customized to output different named integer types,
+# This can be customized to output different named array types,
 # such as `namedarray(a::AbstractArray, name::IndexName) = Index(a, name)`.
 namedarray(a::AbstractArray, name) = NamedArray(a, name)
 
@@ -22,31 +23,32 @@ named(a::AbstractArray, name) = namedarray(a, name)
 # TODO: Use `Accessors.@set`?
 setname(a::AbstractNamedArray, name) = namedarray(denamed(a), name)
 
-# TODO: Use `TypeParameterAccessors`.
-denamedtype(::Type{<:AbstractNamedArray{<:Any, <:Any, Value}}) where {Value} = Value
-nametype(::Type{<:AbstractNamedArray{<:Any, <:Any, <:Any, Name}}) where {Name} = Name
+# `Name` leads, so `nametype` reads it from the abstract type. The wrapped
+# container type lives only on the concrete subtypes, so `denamedtype` is defined
+# per concrete type rather than here.
+nametype(::Type{<:AbstractNamedArray{Name}}) where {Name} = Name
 
 # Traits.
 isnamed(::Type{<:AbstractNamedArray}) = true
 
-# TODO: Should they also have the same base type?
+# Equality and hashing are type-agnostic across named array types, following Base's
+# array convention (`[1, 2, 3] == 1:3`, and they hash equally): two named arrays are
+# equal when their names and denamed values are equal, regardless of concrete type.
+# Hashing uses a single shared tag (not the concrete type) so that
+# `a == b => hash(a) == hash(b)` holds; there are no external subtypes that need to
+# override this.
 function Base.:(==)(a1::AbstractNamedArray, a2::AbstractNamedArray)
     return name(a1) == name(a2) && denamed(a1) == denamed(a2)
 end
-function Base.hash(a::AbstractNamedArray, h::UInt)
-    h = hash(Symbol(unspecify_type_parameters(typeof(a))), h)
-    # TODO: Double check how this is handling blocking/sector information.
-    h = hash(denamed(a), h)
-    return hash(name(a), h)
-end
+Base.hash(a::AbstractNamedArray, h::UInt) = hash_named(:NamedArray, a, h)
 
 getindex_named(a::AbstractArray, I...) = named(getindex(denamed(a), I...), name(a))
 
 # Array funcionality.
 Base.size(a::AbstractNamedArray) = map(s -> named(s, name(a)), size(denamed(a)))
 Base.axes(a::AbstractNamedArray) = map(s -> named(s, name(a)), axes(denamed(a)))
 Base.eachindex(a::AbstractNamedArray) = eachindex(denamed(a))
-function Base.getindex(a::AbstractNamedArray{<:Any, N}, I::Vararg{Int, N}) where {N}
+function Base.getindex(a::AbstractNamedArray{<:Any, <:Any, N}, I::Vararg{Int, N}) where {N}
     return getindex_named(a, I...)
 end
 function Base.getindex(a::AbstractNamedArray, I::Int)