Define hash for the remaining spaces (#700)

* Define hash for the remaining spaces

PR #698 fixed PointSpace and DiracSpace, but every other space in this
package was in the same position: Space.jl:165 defines == as
spacescompatible plus equal domains, while hash fell back to the
identity-based default. Equal-valued spaces therefore hashed differently
whenever they held a mutable field, or whenever the domains compared equal
without being identical objects:

    julia> u1, u2 = UnionDomain([0..1, 2..3]), UnionDomain([2..3, 0..1]);

    julia> ConstantSpace(u1) == ConstantSpace(u2)
    true
    julia> hash(ConstantSpace(u1)) == hash(ConstantSpace(u2))
    false

Since == is a conjunction that includes domain(A) == domain(B), hashing the
domain always agrees with ==, and this is all that is needed for the spaces
that only compare domains: ZeroSpace, ConstantSpace, ContinuousSpace and
SplineSpace. The order of a SplineSpace is part of the type, and it is mixed
in so that splines of different orders over the same domain don't collide.
The remaining spaces additionally hash whatever spacescompatible compares:
the components for SumSpace, PiecewiseSpace, ArraySpace and TensorSpace, the
space and the indices for SubSpace, and the underlying space for
QuotientSpace, whose boundary conditions are not compared by == either.

Two direct sums may hold their pieces in different containers and still be
equal, so their components are hashed one at a time instead of hashing the
container. Base hashes a range through its length, which it can't do for the
infinite ranges that SubSpace often uses, so these are hashed through their
first index and step instead.

PiecewiseSegment overrides == to compare points, so it needs a matching hash
as well; ContinuousSpace and SplineSpace hash it as their domain.

Spaces that compare their domains do so with domainscompatible, which uses
isapprox, so == is not transitive for them and no hash function can respect
it exactly. Hashing the domain reproduces == for exactly equal domains,
which is the case that matters for a Dict or a Set.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ay3nR9CQtrrZj3r5LFu59c

* Bump version from 0.9.37 to 0.9.38

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ay3nR9CQtrrZj3r5LFu59c

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: jishnub

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFunBase"
 uuid = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"
-version = "0.9.37"
+version = "0.9.38"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"

src/Domains/PiecewiseSegment.jl

@@ -26,6 +26,7 @@ function PiecewiseSegment(pcsin::AbstractVector{IT}) where IT<:IntervalOrSegment
 end
 
 ==(a::PiecewiseSegment,b::PiecewiseSegment) = a.points==b.points
+Base.hash(a::PiecewiseSegment, h::UInt) = hash(a.points, hash(PiecewiseSegment, h))
 
 indomain(x, d::PiecewiseSegment) = any(Base.Fix1(in, x), components(d))
 

src/Multivariate/TensorSpace.jl

@@ -329,6 +329,8 @@ dimension(sp::TensorSpace) = mapreduce(dimension,*,sp.spaces)
 ==(A::TensorSpace{<:NTuple{N,Space}}, B::TensorSpace{<:NTuple{N,Space}}) where {N} =
         factors(A) == factors(B)
 
+Base.hash(A::TensorSpace, h::UInt) = hash(factors(A), hash(TensorSpace, h))
+
 conversion_rule(a::TensorSpace{<:NTuple{2,Space}}, b::TensorSpace{<:NTuple{2,Space}}) =
     conversion_type(a.spaces[1],b.spaces[1]) ⊗ conversion_type(a.spaces[2],b.spaces[2])
 

src/Space.jl

@@ -624,6 +624,8 @@ dimension(::ZeroSpace) = 0
 
 spacescompatible(::ZeroSpace,::ZeroSpace) = true
 
+Base.hash(a::ZeroSpace, h::UInt) = hash(domain(a), hash(ZeroSpace, h))
+
 pick_maybe_nonambiguous_space(a::UnsetSpace, b::ZeroSpace) = a
 pick_maybe_nonambiguous_space(a::ZeroSpace, b::UnsetSpace) = b
 

src/Spaces/ArraySpace.jl

@@ -182,6 +182,7 @@ canonicalspace(AS::ArraySpace) = ArraySpace(canonicalspace.(AS.spaces))
 evaluate(f::AbstractVector,S::ArraySpace,x) = map(g->g(x),Fun(S,f))
 
 ==(A::ArraySpace, B::ArraySpace) = size(A) == size(B) && all(((x,y),) -> x==y, zip(A.spaces, B.spaces))
+Base.hash(A::ArraySpace, h::UInt) = hash(A.spaces, hash(ArraySpace, h))
 
 ## choosedomainspace
 

src/Spaces/ConstantSpace.jl

@@ -76,6 +76,8 @@ setdomain(f::Fun{CS},d::Domain) where {CS<:AnyDomain} = Number(f)*ones(d)
 canonicalspace(C::ConstantSpace) = C
 spacescompatible(a::ConstantSpace,b::ConstantSpace)=domainscompatible(a,b)
 
+Base.hash(a::ConstantSpace, h::UInt) = hash(domain(a), hash(ConstantSpace, h))
+
 ones(S::ConstantSpace) = Fun(S,fill(1.0,1))
 ones(S::Union{AnyDomain,UnsetSpace}) = ones(ConstantSpace())
 zeros(S::AnyDomain) = zeros(ConstantSpace())

src/Spaces/ContinuousSpace.jl

@@ -13,6 +13,8 @@ isperiodic(C::ContinuousSpace) = isperiodic(domain(C))
 
 spacescompatible(a::ContinuousSpace, b::ContinuousSpace) = domainscompatible(a,b)
 
+Base.hash(a::ContinuousSpace, h::UInt) = hash(domain(a), hash(ContinuousSpace, h))
+
 plan_transform(sp::ContinuousSpace, vals::AbstractVector) =
     TransformPlan{eltype(vals),typeof(sp),false,Nothing}(sp,nothing)
 

src/Spaces/HeavisideSpace.jl

@@ -21,6 +21,8 @@ convert(::Type{HeavisideSpace},d::AbstractVector) =
 
 spacescompatible(a::SplineSpace{λ},b::SplineSpace{λ}) where {λ} = domainscompatible(a,b)
 
+Base.hash(a::SplineSpace{λ}, h::UInt) where {λ} = hash(domain(a), hash(SplineSpace{λ}, h))
+
 
 function evaluate(c::AbstractVector{T}, s::HeavisideSpace{<:Real}, x::Real) where T
     # the loop below indexes p[k+1] for k up to length(c)

src/Spaces/QuotientSpace.jl

@@ -20,6 +20,8 @@ domain(QS::QuotientSpace) = domain(QS.space)
 canonicalspace(QS::QuotientSpace) = QS.space
 
 spacescompatible(a::QuotientSpace,b::QuotientSpace) = spacescompatible(a.space,b.space)
+# the boundary conditions are not compared by ==, so they are not hashed either
+Base.hash(a::QuotientSpace, h::UInt) = hash(a.space, hash(QuotientSpace, h))
 hasconversion(a::Space,b::QuotientSpace) = hasconversion(a,b.space)
 hasconversion(a::QuotientSpace,b::Space) = hasconversion(a.space,b)
 hasconversion(a::QuotientSpace,b::QuotientSpace) = hasconversion(a.space,b)

src/Spaces/SubSpace.jl

@@ -84,6 +84,14 @@ spacescompatible(S1::SubSpace{DS,IT,DD,RR},S2::SubSpace{DS,IT,DD,RR}) where {DS,
 ==(S1::SubSpace{DS,IT,DD,RR},S2::SubSpace{DS,IT,DD,RR}) where {DS,IT,DD,RR} =
     S1.space == S2.space && S1.indexes == S2.indexes
 
+_hashindexes(ind, h::UInt) = hash(ind, h)
+# Base hashes a range through its length, which it can't do if this is infinite,
+# so we hash the first index and the step in this case
+_hashindexes(ind::AbstractRange, h::UInt) =
+    isinf(length(ind)) ? hash(first(ind), hash(step(ind), h)) : hash(ind, h)
+
+Base.hash(S::SubSpace, h::UInt) = _hashindexes(S.indexes, hash(S.space, hash(SubSpace, h)))
+
 canonicalspace(a::SubSpace) = a.space