use a functor for projection

src/projection.jl

@@ -42,18 +42,12 @@ function (::ProjectTo) end
 # fallback (structs)
 function ProjectTo(x::T) where {T}
     # Generic fallback for structs, recursively make `ProjectTo`s all their fields
-    #println()
-    #@show x
-    #@show T
     fields_nt::NamedTuple = backing(x)
-    #@show fields_nt
     return ProjectTo{T}(map(ProjectTo, fields_nt))
 end
 function (project::ProjectTo{T})(dx::Tangent) where {T}
     sub_projects = backing(project)
-    #@show sub_projects
     sub_dxs = backing(canonicalize(dx))
-    #@show sub_dxs
     _call(f, x) = f(x)
     return construct(T, map(_call, sub_projects, sub_dxs))
 end
@@ -95,7 +89,7 @@ ProjectTo(x::T) where {T<:Diagonal} = ProjectTo{T}(; diag=ProjectTo(diag(x)))
 (project::ProjectTo{T})(dx::AbstractMatrix) where {T<:Diagonal} = T(project.diag(diag(dx)))
 (project::ProjectTo{T})(dx::AbstractZero) where {T<:Diagonal} = T(project.diag(dx))
 
-# Symmetric and Hermitian
+# :data, :uplo fields
 for SymHerm = (:Symmetric, :Hermitian)
     @eval begin
         ProjectTo(x::T) where {T<:$SymHerm} = ProjectTo{T}(; uplo=Symbol(x.uplo), parent=ProjectTo(parent(x)))
@@ -105,16 +99,30 @@ for SymHerm = (:Symmetric, :Hermitian)
     end
 end
 
+# :data field
+for UL = (:UpperTriangular, :LowerTriangular)
+    @eval begin
+        ProjectTo(x::T) where {T<:$UL} = ProjectTo{T}(; parent=ProjectTo(parent(x)))
+        (project::ProjectTo{<:$UL})(dx::AbstractMatrix) = $UL(project.parent(dx))
+        (project::ProjectTo{<:$UL})(dx::AbstractZero) = $UL(project.parent(dx))
+        (project::ProjectTo{<:$UL})(dx::Tangent) = $UL(project.parent(dx.data))
+    end
+end
+
 # Transpose
 ProjectTo(x::T) where {T<:Transpose} = ProjectTo{T}(; parent=ProjectTo(parent(x)))
 (project::ProjectTo{<:Transpose})(dx::AbstractMatrix) = transpose(project.parent(transpose(dx)))
-(project::ProjectTo{<:Transpose})(dx::Adjoint) = transpose(project.parent(conj(parent(dx))))
 (project::ProjectTo{<:Transpose})(dx::AbstractZero) = transpose(project.parent(dx))
 
 # Adjoint
 ProjectTo(x::T) where {T<:Adjoint} = ProjectTo{T}(; parent=ProjectTo(parent(x)))
 (project::ProjectTo{<:Adjoint})(dx::AbstractMatrix) = adjoint(project.parent(adjoint(dx)))
-(project::ProjectTo{<:Adjoint})(dx::ZeroTangent) = adjoint(project.parent(dx))
+(project::ProjectTo{<:Adjoint})(dx::AbstractZero) = adjoint(project.parent(dx))
+
+# PermutedDimsArray
+ProjectTo(x::P) where {P<:PermutedDimsArray} = ProjectTo{P}(; parent=ProjectTo(parent(x)))
+(project::ProjectTo{<:PermutedDimsArray{T,N,perm,iperm,AA}})(dx::AbstractArray) where {T, N, perm, iperm, AA} = PermutedDimsArray{T,N,perm,iperm,AA}(permutedims(project.parent(dx), perm))
+(project::ProjectTo{<:PermutedDimsArray{T,N,perm,iperm,AA}})(dx::AbstractZero) where {T, N, perm, iperm, AA} = PermutedDimsArray{T,N,perm,iperm,AA}(project.parent(dx))
 
 # SubArray
 ProjectTo(x::T) where {T<:SubArray} = ProjectTo(copy(x)) # don't project on to a view, but onto matching copy

test/projection.jl

@@ -179,6 +179,20 @@ end
         @test x == ProjectTo(x)(@thunk(ZeroTangent()))
     end
 
+    @testset "to $UL" for UL in (UpperTriangular, LowerTriangular)
+        data = [1.0+1im 2-2im; 3 4]
+
+        x = UL(data)
+        @test x == ProjectTo(x)(data)
+        @test x == ProjectTo(x)(Tangent{typeof(x)}(; data=data))
+
+        data = [0.0+0im 0; 0 0]
+        x = UL(data)
+        @test x == ProjectTo(x)(Diagonal(zeros(2)))
+        @test x == ProjectTo(x)(ZeroTangent())
+        @test x == ProjectTo(x)(@thunk(ZeroTangent()))
+    end
+
     @testset "to Transpose" begin
         x = rand(ComplexF64, 3, 4)
         t = transpose(x)
@@ -202,6 +216,15 @@ end
         @test zeros(4, 3) == ProjectTo(a)(Tangent{Adjoint}(; parent=ZeroTangent()))
     end
 
+    @testset "to PermutedDimsArray" begin
+        a = zeros(3, 5, 4)
+        b = PermutedDimsArray(a, (2, 1, 3))
+        bc = collect(b)
+
+        @test b == ProjectTo(b)(bc)
+        @test b == ProjectTo(b)(ZeroTangent())
+    end
+
     @testset "to SubArray" begin
         x = rand(3, 4)
         sa = view(x, :, 1:2)