Try fixing tests

Author: mtfishman

Project.toml

@@ -9,6 +9,7 @@ Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
 BackendSelection = "680c2d7c-f67a-4cc9-ae9c-da132b1447a5"
 Combinatorics = "861a8166-3701-5b0c-9a16-15d98fcdc6aa"
 DataGraphs = "b5a273c3-7e6c-41f6-98bd-8d7f1525a36a"
+DerivableInterfaces = "6c5e35bf-e59e-4898-b73c-732dcc4ba65f"
 DiagonalArrays = "74fd4be6-21e2-4f6f-823a-4360d37c7a77"
 Dictionaries = "85a47980-9c8c-11e8-2b9f-f7ca1fa99fb4"
 Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
@@ -34,6 +35,7 @@ Adapt = "4.3"
 BackendSelection = "0.1.6"
 Combinatorics = "1"
 DataGraphs = "0.2.7"
+DerivableInterfaces = "0.5.5"
 DiagonalArrays = "0.3.23"
 Dictionaries = "0.4.5"
 Graphs = "1.13.1"

src/LazyNamedDimsArrays/lazyinterface.jl

@@ -109,6 +109,16 @@ function equals_lazy(a1, a2)
         return false
     end
 end
+function isequal_lazy(a1, a2)
+    u1, u2 = unwrap.((a1, a2))
+    if !iscall(u1) && !iscall(u2)
+        return isequal(u1, u2)
+    elseif ismul(u1) && ismul(u2)
+        return isequal(arguments(u1), arguments(u2))
+    else
+        return false
+    end
+end
 function hash_lazy(a, h::UInt64)
     h = hash(Symbol(unspecify_type_parameters(typeof(a))), h)
     # Use `_hash`, which defines a custom hash for NamedDimsArray.

src/LazyNamedDimsArrays/lazynameddimsarray.jl

@@ -50,6 +50,7 @@ AbstractTrees.nodevalue(a::LazyNamedDimsArray) = nodevalue_lazy(a)
 Base.Broadcast.materialize(a::LazyNamedDimsArray) = materialize_lazy(a)
 Base.copy(a::LazyNamedDimsArray) = copy_lazy(a)
 Base.:(==)(a1::LazyNamedDimsArray, a2::LazyNamedDimsArray) = equals_lazy(a1, a2)
+Base.isequal(a1::LazyNamedDimsArray, a2::LazyNamedDimsArray) = isequal_lazy(a1, a2)
 Base.hash(a::LazyNamedDimsArray, h::UInt64) = hash_lazy(a, h)
 map_arguments(f, a::LazyNamedDimsArray) = map_arguments_lazy(f, a)
 substitute(a::LazyNamedDimsArray, substitutions) = substitute_lazy(a, substitutions)

src/LazyNamedDimsArrays/symbolicarray.jl

@@ -1,3 +1,4 @@
+# TODO: Allow dynamic/unknown number of dimensions by supporting vector axes.
 struct SymbolicArray{T, N, Name, Axes <: NTuple{N, AbstractUnitRange{<:Integer}}} <: AbstractArray{T, N}
     name::Name
     axes::Axes
@@ -26,6 +27,12 @@ end
 function Base.setindex!(a::SymbolicArray{<:Any, N}, value, I::Vararg{Int, N}) where {N}
     return error("Indexing into SymbolicArray not supported.")
 end
+using DerivableInterfaces: DerivableInterfaces
+DerivableInterfaces.permuteddims(a::SymbolicArray, p) = permutedims(a, p)
+function Base.permutedims(a::SymbolicArray, p)
+    @assert ndims(a) == length(p) && isperm(p)
+    return SymbolicArray(symname(a), ntuple(i -> axes(a)[p[i]], ndims(a)))
+end
 function Base.show(io::IO, mime::MIME"text/plain", a::SymbolicArray)
     Base.summary(io, a)
     println(io, ":")

src/LazyNamedDimsArrays/symbolicnameddimsarray.jl

@@ -1,9 +1,9 @@
-using NamedDimsArrays: NamedDimsArray, dename, inds
+using NamedDimsArrays: NamedDimsArray, dename, inds, nameddims
 
 const SymbolicNamedDimsArray{T, N, Parent <: SymbolicArray{T, N}, DimNames} =
     NamedDimsArray{T, N, Parent, DimNames}
 function symnameddims(name, dims)
-    return lazy(NamedDimsArray(SymbolicArray(name, dename.(dims)), dims))
+    return lazy(nameddims(SymbolicArray(name, dename.(dims)), dims))
 end
 symnameddims(name) = symnameddims(name, ())
 using AbstractTrees: AbstractTrees

src/contract_network.jl

@@ -42,7 +42,7 @@ function contraction_order(tn; alg = default_kwargs(contraction_order, tn).alg,
     return contraction_order(to_algorithm(alg; kwargs...), tn)
 end
 function contraction_order(alg::Algorithm"left_associative", tn)
-    return prod(i -> symnameddims(i, Tuple(inds(tn[i]))), eachindex(tn))
+    return prod(i -> symnameddims(i, Tuple(inds(tn[i]))), keys(tn))
 end
 function contraction_order(alg::Algorithm, tn)
     s = contraction_order(tn; alg = Algorithm"left_associative"())