diff --git a/ext/MatrixAlgebraKitGenericLinearAlgebraExt.jl b/ext/MatrixAlgebraKitGenericLinearAlgebraExt.jl
index bd8489364..162f8b220 100644
--- a/ext/MatrixAlgebraKitGenericLinearAlgebraExt.jl
+++ b/ext/MatrixAlgebraKitGenericLinearAlgebraExt.jl
@@ -53,7 +53,7 @@ function heev!(::GLA, A::AbstractMatrix, Dd::AbstractVector, V::AbstractMatrix;
     return Dd, V
 end
 
-function MatrixAlgebraKit.householder_qr!(
+function MatrixAlgebraKit.qr_householder!(
         driver::MatrixAlgebraKit.GLA, A::AbstractMatrix, Q::AbstractMatrix, R::AbstractMatrix;
         positive::Bool = true, pivoted::Bool = false, blocksize::Int = 0
     )
@@ -97,7 +97,7 @@ function MatrixAlgebraKit.householder_qr!(
     return Q, R
 end
 
-function MatrixAlgebraKit.householder_qr_null!(
+function MatrixAlgebraKit.qr_null_householder!(
         driver::MatrixAlgebraKit.GLA, A::AbstractMatrix, N::AbstractMatrix;
         positive::Bool = true, pivoted::Bool = false, blocksize::Int = 0
     )
diff --git a/src/implementations/eig.jl b/src/implementations/eig.jl
index e2182e298..65fe5a759 100644
--- a/src/implementations/eig.jl
+++ b/src/implementations/eig.jl
@@ -103,29 +103,32 @@ for f! in (:geev!, :geevx!)
 end
 
 # driver dispatch
-@inline qr_iteration_eig_full!(A, Dd, V; driver::Driver = DefaultDriver(), kwargs...) =
-    qr_iteration_eig_full!(driver, A, Dd, V; kwargs...)
-@inline qr_iteration_eig_vals!(A, D, V; driver::Driver = DefaultDriver(), kwargs...) =
-    qr_iteration_eig_vals!(driver, A, D, V; kwargs...)
+@inline eig_full_qr_iteration!(A, DV; driver::Driver = DefaultDriver(), kwargs...) =
+    eig_full_qr_iteration!(driver, A, DV; kwargs...)
+@inline eig_vals_qr_iteration!(A, D; driver::Driver = DefaultDriver(), kwargs...) =
+    eig_vals_qr_iteration!(driver, A, D; kwargs...)
 
-@inline qr_iteration_eig_full!(::DefaultDriver, A, Dd, V; kwargs...) =
-    qr_iteration_eig_full!(default_driver(QRIteration, A), A, Dd, V; kwargs...)
-@inline qr_iteration_eig_vals!(::DefaultDriver, A, D, V; kwargs...) =
-    qr_iteration_eig_vals!(default_driver(QRIteration, A), A, D, V; kwargs...)
+@inline eig_full_qr_iteration!(::DefaultDriver, A, DV; kwargs...) =
+    eig_full_qr_iteration!(default_driver(QRIteration, A), A, DV; kwargs...)
+@inline eig_vals_qr_iteration!(::DefaultDriver, A, D; kwargs...) =
+    eig_vals_qr_iteration!(default_driver(QRIteration, A), A, D; kwargs...)
 
 # Implementation
-function qr_iteration_eig_full!(
-        driver::Driver, A, Dd, V;
+function eig_full_qr_iteration!(
+        driver::Driver, A, DV;
         fixgauge::Bool = default_fixgauge(), scale::Bool = true, permute::Bool = true
     )
+    D, V = DV
+    Dd = diagview(D)
     (scale & permute) ? geev!(driver, A, Dd, V) : geevx!(driver, A, Dd, V; scale, permute)
     fixgauge && gaugefix!(eig_full!, V)
-    return Dd, V
+    return DV
 end
-function qr_iteration_eig_vals!(
-        driver::Driver, A, D, V;
+function eig_vals_qr_iteration!(
+        driver::Driver, A, D;
         fixgauge::Bool = default_fixgauge(), scale::Bool = true, permute::Bool = true
     )
+    V = similar(A, complex(eltype(A)), (size(A, 1), 0))
     (scale & permute) ? geev!(driver, A, D, V) : geevx!(driver, A, D, V; scale, permute)
     return D
 end
@@ -133,14 +136,12 @@ end
 # Top-level QRIteration dispatch
 function eig_full!(A::AbstractMatrix, DV, alg::QRIteration)
     check_input(eig_full!, A, DV, alg)
-    D, V = DV
-    qr_iteration_eig_full!(A, diagview(D), V; alg.kwargs...)
-    return D, V
+    eig_full_qr_iteration!(A, DV; alg.kwargs...)
+    return DV
 end
 function eig_vals!(A::AbstractMatrix, D, alg::QRIteration)
     check_input(eig_vals!, A, D, alg)
-    V = similar(A, complex(eltype(A)), (size(A, 1), 0))
-    qr_iteration_eig_vals!(A, D, V; alg.kwargs...)
+    eig_vals_qr_iteration!(A, D; alg.kwargs...)
     return D
 end
 
diff --git a/src/implementations/eigh.jl b/src/implementations/eigh.jl
index 2c755042c..bfe8df216 100644
--- a/src/implementations/eigh.jl
+++ b/src/implementations/eigh.jl
@@ -115,46 +115,47 @@ for (f, f_lapack!, Alg) in (
         (:bisection, :heevx!, :Bisection),
         (:jacobi, :heevj!, :Jacobi),
     )
-    f_eigh_full! = Symbol(f, :_eigh_full!)
-    f_eigh_vals! = Symbol(f, :_eigh_vals!)
+    eigh_full_f! = Symbol(:eigh_full_, f, :!)
+    eigh_vals_f! = Symbol(:eigh_vals_, f, :!)
 
     # MatrixAlgebraKit wrappers
     @eval begin
         function eigh_full!(A::AbstractMatrix, DV, alg::$Alg)
             check_input(eigh_full!, A, DV, alg)
-            D, V = DV
-            Dd, V = $f_eigh_full!(A, D.diag, V; alg.kwargs...)
-            return D, V
+            $eigh_full_f!(A, DV; alg.kwargs...)
+            return DV
         end
         function eigh_vals!(A::AbstractMatrix, D, alg::$Alg)
             check_input(eigh_vals!, A, D, alg)
-            V = similar(A, (size(A, 1), 0))
-            $f_eigh_vals!(A, D, V; alg.kwargs...)
+            $eigh_vals_f!(A, D; alg.kwargs...)
             return D
         end
     end
 
     # driver dispatch
     @eval begin
-        @inline $f_eigh_full!(A, Dd, V; driver::Driver = DefaultDriver(), kwargs...) =
-            $f_eigh_full!(driver, A, Dd, V; kwargs...)
-        @inline $f_eigh_vals!(A, D, V; driver::Driver = DefaultDriver(), kwargs...) =
-            $f_eigh_vals!(driver, A, D, V; kwargs...)
+        @inline $eigh_full_f!(A, DV; driver::Driver = DefaultDriver(), kwargs...) =
+            $eigh_full_f!(driver, A, DV; kwargs...)
+        @inline $eigh_vals_f!(A, D; driver::Driver = DefaultDriver(), kwargs...) =
+            $eigh_vals_f!(driver, A, D; kwargs...)
 
-        @inline $f_eigh_full!(::DefaultDriver, A, Dd, V; kwargs...) =
-            $f_eigh_full!(default_driver($Alg, A), A, Dd, V; kwargs...)
-        @inline $f_eigh_vals!(::DefaultDriver, A, D, V; kwargs...) =
-            $f_eigh_vals!(default_driver($Alg, A), A, D, V; kwargs...)
+        @inline $eigh_full_f!(::DefaultDriver, A, DV; kwargs...) =
+            $eigh_full_f!(default_driver($Alg, A), A, DV; kwargs...)
+        @inline $eigh_vals_f!(::DefaultDriver, A, D; kwargs...) =
+            $eigh_vals_f!(default_driver($Alg, A), A, D; kwargs...)
     end
 
     # Implementation
     @eval begin
-        function $f_eigh_full!(driver::Driver, A, Dd, V; fixgauge::Bool = default_fixgauge(), kwargs...)
+        function $eigh_full_f!(driver::Driver, A, DV; fixgauge::Bool = default_fixgauge(), kwargs...)
+            D, V = DV
+            Dd = diagview(D)
             $f_lapack!(driver, A, Dd, V; kwargs...)
             fixgauge && gaugefix!(eigh_full!, V)
-            return Dd, V
+            return DV
         end
-        function $f_eigh_vals!(driver::Driver, A, D, V; fixgauge::Bool = default_fixgauge(), kwargs...)
+        function $eigh_vals_f!(driver::Driver, A, D; fixgauge::Bool = default_fixgauge(), kwargs...)
+            V = similar(A, (size(A, 1), 0))
             $f_lapack!(driver, A, D, V; kwargs...)
             return D
         end
diff --git a/src/implementations/lq.jl b/src/implementations/lq.jl
index 28acbfd23..dbfcdcb39 100644
--- a/src/implementations/lq.jl
+++ b/src/implementations/lq.jl
@@ -105,15 +105,15 @@ end
 # -----------
 function lq_full!(A, LQ, alg::Householder)
     check_input(lq_full!, A, LQ, alg)
-    return householder_lq!(A, LQ...; alg.kwargs...)
+    return lq_householder!(A, LQ...; alg.kwargs...)
 end
 function lq_compact!(A, LQ, alg::Householder)
     check_input(lq_compact!, A, LQ, alg)
-    return householder_lq!(A, LQ...; alg.kwargs...)
+    return lq_householder!(A, LQ...; alg.kwargs...)
 end
 function lq_null!(A, Nᴴ, alg::Householder)
     check_input(lq_null!, A, Nᴴ, alg)
-    return householder_lq_null!(A, Nᴴ; alg.kwargs...)
+    return lq_null_householder!(A, Nᴴ; alg.kwargs...)
 end
 
 # dispatch helpers
@@ -123,13 +123,13 @@ for f in (:gelqt!, :gemlqt!, :gelqf!, :unglq!, :unmlq!)
     end
 end
 
-@inline householder_lq!(A, L, Q; driver::Driver = DefaultDriver(), kwargs...) =
-    householder_lq!(driver, A, L, Q; kwargs...)
-householder_lq!(::DefaultDriver, A, L, Q; kwargs...) =
-    householder_lq!(default_driver(Householder, A), A, L, Q; kwargs...)
-householder_lq!(driver::Union{CUSOLVER, ROCSOLVER, GLA}, A, L, Q; kwargs...) =
+@inline lq_householder!(A, L, Q; driver::Driver = DefaultDriver(), kwargs...) =
+    lq_householder!(driver, A, L, Q; kwargs...)
+lq_householder!(::DefaultDriver, A, L, Q; kwargs...) =
+    lq_householder!(default_driver(Householder, A), A, L, Q; kwargs...)
+lq_householder!(driver::Union{CUSOLVER, ROCSOLVER, GLA}, A, L, Q; kwargs...) =
     lq_via_qr!(A, L, Q, Householder(; driver, kwargs...))
-function householder_lq!(
+function lq_householder!(
         driver::LAPACK, A::AbstractMatrix, L::AbstractMatrix, Q::AbstractMatrix;
         positive = true, pivoted = false, blocksize::Int = 0
     )
@@ -186,7 +186,7 @@ function householder_lq!(
     end
     return L, Q
 end
-function householder_lq!(
+function lq_householder!(
         driver::Native, A::AbstractMatrix, L::AbstractMatrix, Q::AbstractMatrix;
         positive::Bool = true, pivoted::Bool = false, blocksize::Int = 0
     )
@@ -229,13 +229,13 @@ function householder_lq!(
     return L, Q
 end
 
-@inline householder_lq_null!(A, Nᴴ; driver::Driver = DefaultDriver(), kwargs...) =
-    householder_lq_null!(driver, A, Nᴴ; kwargs...)
-householder_lq_null!(::DefaultDriver, A, Nᴴ; kwargs...) =
-    householder_lq_null!(default_driver(Householder, A), A, Nᴴ; kwargs...)
-householder_lq_null!(driver::Union{CUSOLVER, ROCSOLVER, GLA}, A, Nᴴ; kwargs...) =
+@inline lq_null_householder!(A, Nᴴ; driver::Driver = DefaultDriver(), kwargs...) =
+    lq_null_householder!(driver, A, Nᴴ; kwargs...)
+lq_null_householder!(::DefaultDriver, A, Nᴴ; kwargs...) =
+    lq_null_householder!(default_driver(Householder, A), A, Nᴴ; kwargs...)
+lq_null_householder!(driver::Union{CUSOLVER, ROCSOLVER, GLA}, A, Nᴴ; kwargs...) =
     lq_null_via_qr!(A, Nᴴ, Householder(; driver, kwargs...))
-function householder_lq_null!(
+function lq_null_householder!(
         driver::LAPACK, A::AbstractMatrix, Nᴴ::AbstractMatrix;
         positive::Bool = true, pivoted::Bool = false, blocksize::Int = 0
     )
@@ -260,7 +260,7 @@ function householder_lq_null!(
     end
     return Nᴴ
 end
-function householder_lq_null!(
+function lq_null_householder!(
         driver::Native, A::AbstractMatrix, Nᴴ::AbstractMatrix;
         positive::Bool = true, pivoted::Bool = false, blocksize::Int = 0
     )
@@ -343,21 +343,21 @@ end
 function lq_full!(A::AbstractMatrix, LQ, alg::DiagonalAlgorithm)
     check_input(lq_full!, A, LQ, alg)
     L, Q = LQ
-    _diagonal_lq!(A, L, Q; alg.kwargs...)
+    lq_diagonal!(A, L, Q; alg.kwargs...)
     return L, Q
 end
 function lq_compact!(A::AbstractMatrix, LQ, alg::DiagonalAlgorithm)
     check_input(lq_compact!, A, LQ, alg)
     L, Q = LQ
-    _diagonal_lq!(A, L, Q; alg.kwargs...)
+    lq_diagonal!(A, L, Q; alg.kwargs...)
     return L, Q
 end
 function lq_null!(A::AbstractMatrix, N, alg::DiagonalAlgorithm)
     check_input(lq_null!, A, N, alg)
-    return _diagonal_lq_null!(A, N; alg.kwargs...)
+    return lq_null_diagonal!(A, N; alg.kwargs...)
 end
 
-function _diagonal_lq!(
+function lq_diagonal!(
         A::AbstractMatrix, L::AbstractMatrix, Q::AbstractMatrix; positive::Bool = true
     )
     # note: Ad and Qd might share memory here so order of operations is important
@@ -374,7 +374,7 @@ function _diagonal_lq!(
     return L, Q
 end
 
-_diagonal_lq_null!(A::AbstractMatrix, N; positive::Bool = true) = N
+lq_null_diagonal!(A::AbstractMatrix, N; positive::Bool = true) = N
 
 # Deprecations
 # ------------
diff --git a/src/implementations/polar.jl b/src/implementations/polar.jl
index 3cbdab15b..1cfdbda94 100644
--- a/src/implementations/polar.jl
+++ b/src/implementations/polar.jl
@@ -100,10 +100,10 @@ function left_polar!(A::AbstractMatrix, WP, alg::PolarNewton)
     check_input(left_polar!, A, WP, alg)
     W, P = WP
     if isempty(P)
-        W = _left_polarnewton!(A, W, P; alg.kwargs...)
+        W = left_polar_newton!(A, W, P; alg.kwargs...)
         return W, P
     else
-        W = _left_polarnewton!(copy(A), W, P; alg.kwargs...)
+        W = left_polar_newton!(copy(A), W, P; alg.kwargs...)
         # we still need `A` to compute `P`
         P = project_hermitian!(mul!(P, W', A))
         return W, P
@@ -114,10 +114,10 @@ function right_polar!(A::AbstractMatrix, PWᴴ, alg::PolarNewton)
     check_input(right_polar!, A, PWᴴ, alg)
     P, Wᴴ = PWᴴ
     if isempty(P)
-        Wᴴ = _right_polarnewton!(A, Wᴴ, P; alg.kwargs...)
+        Wᴴ = right_polar_newton!(A, Wᴴ, P; alg.kwargs...)
         return P, Wᴴ
     else
-        Wᴴ = _right_polarnewton!(copy(A), Wᴴ, P; alg.kwargs...)
+        Wᴴ = right_polar_newton!(copy(A), Wᴴ, P; alg.kwargs...)
         # we still need `A` to compute `P`
         P = project_hermitian!(mul!(P, A, Wᴴ'))
         return P, Wᴴ
@@ -125,7 +125,7 @@ function right_polar!(A::AbstractMatrix, PWᴴ, alg::PolarNewton)
 end
 
 # these methods only compute W and destroy A in the process
-function _left_polarnewton!(A::AbstractMatrix, W, P = similar(A, (0, 0)); tol = defaulttol(A), maxiter = 10)
+function left_polar_newton!(A::AbstractMatrix, W, P = similar(A, (0, 0)); tol = defaulttol(A), maxiter = 10)
     m, n = size(A) # we must have m >= n
     Rᴴinv = isempty(P) ? similar(P, (n, n)) : P # use P as workspace when available
     if m > n # initial QR
@@ -165,7 +165,7 @@ function _left_polarnewton!(A::AbstractMatrix, W, P = similar(A, (0, 0)); tol =
     return W
 end
 
-function _right_polarnewton!(A::AbstractMatrix, Wᴴ, P = similar(A, (0, 0)); tol = defaulttol(A), maxiter = 10)
+function right_polar_newton!(A::AbstractMatrix, Wᴴ, P = similar(A, (0, 0)); tol = defaulttol(A), maxiter = 10)
     m, n = size(A) # we must have m <= n
     Lᴴinv = isempty(P) ? similar(P, (m, m)) : P # use P as workspace when available
     if m < n # initial QR
diff --git a/src/implementations/qr.jl b/src/implementations/qr.jl
index a0abb734f..e490724cd 100644
--- a/src/implementations/qr.jl
+++ b/src/implementations/qr.jl
@@ -105,15 +105,15 @@ end
 # -----------
 function qr_full!(A, QR, alg::Householder)
     check_input(qr_full!, A, QR, alg)
-    return householder_qr!(A, QR...; alg.kwargs...)
+    return qr_householder!(A, QR...; alg.kwargs...)
 end
 function qr_compact!(A, QR, alg::Householder)
     check_input(qr_compact!, A, QR, alg)
-    return householder_qr!(A, QR...; alg.kwargs...)
+    return qr_householder!(A, QR...; alg.kwargs...)
 end
 function qr_null!(A, N, alg::Householder)
     check_input(qr_null!, A, N, alg)
-    return householder_qr_null!(A, N; alg.kwargs...)
+    return qr_null_householder!(A, N; alg.kwargs...)
 end
 
 
@@ -125,11 +125,11 @@ for f in (:geqrt!, :gemqrt!, :geqp3!, :geqrf!, :ungqr!, :unmqr!)
     end
 end
 
-@inline householder_qr!(A, Q, R; driver::Driver = DefaultDriver(), kwargs...) =
-    householder_qr!(driver, A, Q, R; kwargs...)
-householder_qr!(::DefaultDriver, A, Q, R; kwargs...) =
-    householder_qr!(default_driver(Householder, A), A, Q, R; kwargs...)
-function householder_qr!(
+@inline qr_householder!(A, Q, R; driver::Driver = DefaultDriver(), kwargs...) =
+    qr_householder!(driver, A, Q, R; kwargs...)
+qr_householder!(::DefaultDriver, A, Q, R; kwargs...) =
+    qr_householder!(default_driver(Householder, A), A, Q, R; kwargs...)
+function qr_householder!(
         driver::Union{LAPACK, CUSOLVER, ROCSOLVER}, A::AbstractMatrix, Q::AbstractMatrix, R::AbstractMatrix;
         positive::Bool = true, pivoted::Bool = false,
         blocksize::Int = 0
@@ -213,7 +213,7 @@ function householder_qr!(
     end
     return Q, R
 end
-function householder_qr!(
+function qr_householder!(
         driver::Native, A::AbstractMatrix, Q::AbstractMatrix, R::AbstractMatrix;
         positive::Bool = true, pivoted::Bool = false, blocksize::Int = 0
     )
@@ -256,11 +256,11 @@ function householder_qr!(
     return Q, R
 end
 
-@inline householder_qr_null!(A, N; driver::Driver = DefaultDriver(), kwargs...) =
-    householder_qr_null!(driver, A, N; kwargs...)
-householder_qr_null!(::DefaultDriver, A, N; kwargs...) =
-    householder_qr_null!(default_driver(Householder, A), A, N; kwargs...)
-function householder_qr_null!(
+@inline qr_null_householder!(A, N; driver::Driver = DefaultDriver(), kwargs...) =
+    qr_null_householder!(driver, A, N; kwargs...)
+qr_null_householder!(::DefaultDriver, A, N; kwargs...) =
+    qr_null_householder!(default_driver(Householder, A), A, N; kwargs...)
+function qr_null_householder!(
         driver::Union{LAPACK, CUSOLVER, ROCSOLVER}, A::AbstractMatrix, N::AbstractMatrix;
         positive::Bool = true, pivoted::Bool = false, blocksize::Int = 0
     )
@@ -288,7 +288,7 @@ function householder_qr_null!(
     end
     return N
 end
-function householder_qr_null!(
+function qr_null_householder!(
         driver::Native, A::AbstractMatrix, N::AbstractMatrix;
         positive::Bool = true, pivoted::Bool = false, blocksize::Int = 0
     )
diff --git a/src/implementations/schur.jl b/src/implementations/schur.jl
index d87d25a34..6a12e754b 100644
--- a/src/implementations/schur.jl
+++ b/src/implementations/schur.jl
@@ -65,23 +65,25 @@ for f! in (:gees!, :geesx!)
 end
 
 # driver dispatch
-@inline qr_iteration_schur_full!(A, T, Z, vals; driver::Driver = DefaultDriver(), kwargs...) =
-    qr_iteration_schur_full!(driver, A, T, Z, vals; kwargs...)
-@inline qr_iteration_schur_vals!(A, Z, vals; driver::Driver = DefaultDriver(), kwargs...) =
-    qr_iteration_schur_vals!(driver, A, Z, vals; kwargs...)
+@inline schur_full_qr_iteration!(A, TZv; driver::Driver = DefaultDriver(), kwargs...) =
+    schur_full_qr_iteration!(driver, A, TZv; kwargs...)
+@inline schur_vals_qr_iteration!(A, vals; driver::Driver = DefaultDriver(), kwargs...) =
+    schur_vals_qr_iteration!(driver, A, vals; kwargs...)
 
-@inline qr_iteration_schur_full!(::DefaultDriver, A, T, Z, vals; kwargs...) =
-    qr_iteration_schur_full!(default_driver(QRIteration, A), A, T, Z, vals; kwargs...)
-@inline qr_iteration_schur_vals!(::DefaultDriver, A, Z, vals; kwargs...) =
-    qr_iteration_schur_vals!(default_driver(QRIteration, A), A, Z, vals; kwargs...)
+@inline schur_full_qr_iteration!(::DefaultDriver, A, TZv; kwargs...) =
+    schur_full_qr_iteration!(default_driver(QRIteration, A), A, TZv; kwargs...)
+@inline schur_vals_qr_iteration!(::DefaultDriver, A, vals; kwargs...) =
+    schur_vals_qr_iteration!(default_driver(QRIteration, A), A, vals; kwargs...)
 
 # Implementation
-function qr_iteration_schur_full!(driver::Driver, A, T, Z, vals; expert::Bool = false)
+function schur_full_qr_iteration!(driver::Driver, A, TZv; expert::Bool = false)
+    T, Z, vals = TZv
     expert ? geesx!(driver, A, Z, vals) : gees!(driver, A, Z, vals)
     T === A || copy!(T, A)
-    return T, Z, vals
+    return TZv
 end
-function qr_iteration_schur_vals!(driver::Driver, A, Z, vals; expert::Bool = false)
+function schur_vals_qr_iteration!(driver::Driver, A, vals; expert::Bool = false)
+    Z = similar(A, eltype(A), (size(A, 1), 0))
     expert ? geesx!(driver, A, Z, vals) : gees!(driver, A, Z, vals)
     return vals
 end
@@ -89,14 +91,12 @@ end
 # Top-level QRIteration dispatch
 function schur_full!(A::AbstractMatrix, TZv, alg::QRIteration)
     check_input(schur_full!, A, TZv, alg)
-    T, Z, vals = TZv
-    qr_iteration_schur_full!(A, T, Z, vals; alg.kwargs...)
-    return T, Z, vals
+    schur_full_qr_iteration!(A, TZv; alg.kwargs...)
+    return TZv
 end
 function schur_vals!(A::AbstractMatrix, vals, alg::QRIteration)
     check_input(schur_vals!, A, vals, alg)
-    Z = similar(A, eltype(A), (size(A, 1), 0))
-    qr_iteration_schur_vals!(A, Z, vals; alg.kwargs...)
+    schur_vals_qr_iteration!(A, vals; alg.kwargs...)
     return vals
 end
 
diff --git a/src/implementations/svd.jl b/src/implementations/svd.jl
index 32baf401f..1a1f2e34b 100644
--- a/src/implementations/svd.jl
+++ b/src/implementations/svd.jl
@@ -160,46 +160,46 @@ for (f, f_lapack!, Alg) in (
         (:jacobi, :gesvdj!, :Jacobi),
         (:svd_polar, :gesvdp!, :SVDViaPolar),
     )
-    f_svd! = Symbol(f, :_svd!)
-    f_svd_full! = Symbol(f, :_svd_full!)
-    f_svd_vals! = Symbol(f, :_svd_vals!)
+    svd_compact_f! = Symbol(:svd_compact_, f, :!)
+    svd_full_f! = Symbol(:svd_full_, f, :!)
+    svd_vals_f! = Symbol(:svd_vals_, f, :!)
 
     # MatrixAlgebraKit wrappers
     @eval begin
         function svd_compact!(A, USVᴴ, alg::$Alg)
             check_input(svd_compact!, A, USVᴴ, alg)
-            return $f_svd!(A, USVᴴ...; alg.kwargs...)
+            return $svd_compact_f!(A, USVᴴ...; alg.kwargs...)
         end
         function svd_full!(A, USVᴴ, alg::$Alg)
             check_input(svd_full!, A, USVᴴ, alg)
-            return $f_svd_full!(A, USVᴴ...; alg.kwargs...)
+            return $svd_full_f!(A, USVᴴ...; alg.kwargs...)
         end
         function svd_vals!(A, S, alg::$Alg)
             check_input(svd_vals!, A, S, alg)
-            return $f_svd_vals!(A, S; alg.kwargs...)
+            return $svd_vals_f!(A, S; alg.kwargs...)
         end
     end
 
     # driver
     @eval begin
-        @inline $f_svd!(A, U, S, Vᴴ; driver::Driver = DefaultDriver(), kwargs...) = $f_svd!(driver, A, U, S, Vᴴ; kwargs...)
-        @inline $f_svd_full!(A, U, S, Vᴴ; driver::Driver = DefaultDriver(), kwargs...) = $f_svd_full!(driver, A, U, S, Vᴴ; kwargs...)
-        @inline $f_svd_vals!(A, S; driver::Driver = DefaultDriver(), kwargs...) = $f_svd_vals!(driver, A, S; kwargs...)
+        @inline $svd_compact_f!(A, U, S, Vᴴ; driver::Driver = DefaultDriver(), kwargs...) = $svd_compact_f!(driver, A, U, S, Vᴴ; kwargs...)
+        @inline $svd_full_f!(A, U, S, Vᴴ; driver::Driver = DefaultDriver(), kwargs...) = $svd_full_f!(driver, A, U, S, Vᴴ; kwargs...)
+        @inline $svd_vals_f!(A, S; driver::Driver = DefaultDriver(), kwargs...) = $svd_vals_f!(driver, A, S; kwargs...)
 
-        @inline $f_svd!(::DefaultDriver, A, U, S, Vᴴ; kwargs...) = $f_svd!(default_driver($Alg, A), A, U, S, Vᴴ; kwargs...)
-        @inline $f_svd_full!(::DefaultDriver, A, U, S, Vᴴ; kwargs...) = $f_svd_full!(default_driver($Alg, A), A, U, S, Vᴴ; kwargs...)
-        @inline $f_svd_vals!(::DefaultDriver, A, S; kwargs...) = $f_svd_vals!(default_driver($Alg, A), A, S; kwargs...)
+        @inline $svd_compact_f!(::DefaultDriver, A, U, S, Vᴴ; kwargs...) = $svd_compact_f!(default_driver($Alg, A), A, U, S, Vᴴ; kwargs...)
+        @inline $svd_full_f!(::DefaultDriver, A, U, S, Vᴴ; kwargs...) = $svd_full_f!(default_driver($Alg, A), A, U, S, Vᴴ; kwargs...)
+        @inline $svd_vals_f!(::DefaultDriver, A, S; kwargs...) = $svd_vals_f!(default_driver($Alg, A), A, S; kwargs...)
     end
 
     # Implementation
     @eval begin
-        function $f_svd!(driver::Driver, A, U, S, Vᴴ; fixgauge::Bool = true, kwargs...)
+        function $svd_compact_f!(driver::Driver, A, U, S, Vᴴ; fixgauge::Bool = true, kwargs...)
             isempty(A) && return one!(U), zero!(S), one!(Vᴴ)
             $f_lapack!(driver, A, diagview(S), U, Vᴴ; kwargs...)
             fixgauge && gaugefix!(svd_compact!, U, Vᴴ)
             return U, S, Vᴴ
         end
-        function $f_svd_full!(driver::Driver, A, U, S, Vᴴ; fixgauge::Bool = true, kwargs...)
+        function $svd_full_f!(driver::Driver, A, U, S, Vᴴ; fixgauge::Bool = true, kwargs...)
             supports_svd_full(driver, $(QuoteNode(f))) ||
                 throw(ArgumentError(LazyString("driver ", driver, " does not provide `$($(QuoteNode(f_lapack!)))`")))
             isempty(A) && return one!(U), zero!(S), one!(Vᴴ)
@@ -211,7 +211,7 @@ for (f, f_lapack!, Alg) in (
             fixgauge && gaugefix!(svd_full!, U, Vᴴ)
             return U, S, Vᴴ
         end
-        function $f_svd_vals!(driver::Driver, A, S; fixgauge::Bool = true, kwargs...)
+        function $svd_vals_f!(driver::Driver, A, S; fixgauge::Bool = true, kwargs...)
             isempty(A) && return zero!(S)
             U, Vᴴ = similar(A, (0, 0)), similar(A, (0, 0))
             $f_lapack!(driver, A, S, U, Vᴴ; kwargs...)