more or less give up and just force things to be type stable

Author: lkdvos

src/algorithms.jl

@@ -100,7 +100,9 @@ Finally, the same behavior is obtained when the keyword arguments are
 passed as the third positional argument in the form of a `NamedTuple`. 
 """ select_algorithm
 
-@inline function select_algorithm(f::F, A, alg::Alg = nothing; kwargs...) where {F, Alg}
+# WARNING: In order to keep everything type stable, this function is marked as foldable.
+# This mostly means that the `default_algorithm` implementation must be foldable as well
+Base.@assume_effects :foldable function select_algorithm(f::F, A, alg::Alg = nothing; kwargs...) where {F, Alg}
     if isnothing(alg)
         return default_algorithm(f, A; kwargs...)
     elseif alg isa Symbol
@@ -129,8 +131,10 @@ In general, this is called by [`select_algorithm`](@ref) if no algorithm is spec
 explicitly.
 New types should prefer to register their default algorithms in the type domain.
 """ default_algorithm
-default_algorithm(f::F, A; kwargs...) where {F} = default_algorithm(f, typeof(A); kwargs...)
-default_algorithm(f::F, A, B; kwargs...) where {F} = default_algorithm(f, typeof(A), typeof(B); kwargs...)
+@inline default_algorithm(f::F, A; kwargs...) where {F} =
+    default_algorithm(f, typeof(A); kwargs...)
+@inline default_algorithm(f::F, A, B; kwargs...) where {F} =
+    default_algorithm(f, typeof(A), typeof(B); kwargs...)
 # avoid infinite recursion:
 function default_algorithm(f::F, ::Type{T}; kwargs...) where {F, T}
     throw(MethodError(default_algorithm, (f, T)))

src/interface/decompositions.jl

@@ -79,12 +79,11 @@ The optional `driver` symbol can be used to choose between different implementat
 Depending on the driver, various other keywords may be (un)available to customize the implementation.
 """
 @algdef Householder
-
 function Householder(;
-        driver::Driver = DefaultDriver(), blocksize::Int = 0,
+        blocksize::Int = 0, driver::Driver = DefaultDriver(),
         pivoted::Bool = false, positive::Bool = true
     )
-    return Householder((; driver, blocksize, pivoted, positive))
+    return Householder((; blocksize, driver, pivoted, positive))
 end
 
 default_householder_driver(A) = default_householder_driver(typeof(A))

src/interface/lq.jl

@@ -71,8 +71,8 @@ See also [`qr_full(!)`](@ref lq_full) and [`qr_compact(!)`](@ref lq_compact).
 default_lq_algorithm(A; kwargs...) = default_lq_algorithm(typeof(A); kwargs...)
 
 default_lq_algorithm(T::Type; kwargs...) = throw(MethodError(default_lq_algorithm, (T,)))
-default_lq_algorithm(::Type{T}; driver = default_householder_driver(T), kwargs...) where {T <: AbstractMatrix} =
-    Householder(; driver, kwargs...)
+default_lq_algorithm(::Type{T}; kwargs...) where {T <: AbstractMatrix} =
+    Householder(; kwargs...)
 default_lq_algorithm(::Type{T}; kwargs...) where {T <: Diagonal} =
     DiagonalAlgorithm(; kwargs...)
 default_lq_algorithm(::Type{<:Base.ReshapedArray{T, N, A}}) where {T, N, A} =

src/interface/orthnull.jl

@@ -334,79 +334,79 @@ See also [`left_null(!)`](@ref left_null), [`left_orth(!)`](@ref left_orth) and
 @inline select_algorithm(::typeof(right_null!), A, alg::Symbol; kwargs...) =
     select_algorithm(right_null!, A, Val(alg); kwargs...)
 
-function select_algorithm(::typeof(left_orth!), A, ::Val{:qr}; trunc = nothing, kwargs...)
+@inline function select_algorithm(::typeof(left_orth!), A, ::Val{:qr}; trunc = nothing, kwargs...)
     isnothing(trunc) ||
         throw(ArgumentError("QR-based `left_orth` is incompatible with specifying `trunc`"))
     alg′ = select_algorithm(qr_compact!, A; kwargs...)
     return LeftOrthViaQR(alg′)
 end
-function select_algorithm(::typeof(left_orth!), A, ::Val{:polar}; trunc = nothing, kwargs...)
+@inline function select_algorithm(::typeof(left_orth!), A, ::Val{:polar}; trunc = nothing, kwargs...)
     isnothing(trunc) ||
         throw(ArgumentError("Polar-based `left_orth` is incompatible with specifying `trunc`"))
     alg′ = select_algorithm(left_polar!, A; kwargs...)
     return LeftOrthViaPolar(alg′)
 end
-function select_algorithm(::typeof(left_orth!), A, ::Val{:svd}; trunc = nothing, kwargs...)
+@inline function select_algorithm(::typeof(left_orth!), A, ::Val{:svd}; trunc = nothing, kwargs...)
     alg′ = isnothing(trunc) ? select_algorithm(svd_compact!, A; kwargs...) :
         select_algorithm(svd_trunc!, A; trunc, kwargs...)
     return LeftOrthViaSVD(alg′)
 end
 
-function select_algorithm(::typeof(right_orth!), A, ::Val{:lq}; trunc = nothing, kwargs...)
+@inline function select_algorithm(::typeof(right_orth!), A, ::Val{:lq}; trunc = nothing, kwargs...)
     isnothing(trunc) ||
         throw(ArgumentError("LQ-based `right_orth` is incompatible with specifying `trunc`"))
     alg = select_algorithm(lq_compact!, A; kwargs...)
     return RightOrthViaLQ(alg)
 end
-function select_algorithm(::typeof(right_orth!), A, ::Val{:polar}; trunc = nothing, kwargs...)
+@inline function select_algorithm(::typeof(right_orth!), A, ::Val{:polar}; trunc = nothing, kwargs...)
     isnothing(trunc) ||
         throw(ArgumentError("Polar-based `right_orth` is incompatible with specifying `trunc`"))
     alg = select_algorithm(right_polar!, A; kwargs...)
     return RightOrthViaPolar(alg)
 end
-function select_algorithm(::typeof(right_orth!), A, ::Val{:svd}; trunc = nothing, kwargs...)
+@inline function select_algorithm(::typeof(right_orth!), A, ::Val{:svd}; trunc = nothing, kwargs...)
     alg′ = isnothing(trunc) ? select_algorithm(svd_compact!, A; kwargs...) :
         select_algorithm(svd_trunc!, A; trunc, kwargs...)
     return RightOrthViaSVD(alg′)
 end
 
-function select_algorithm(::typeof(left_null!), A, ::Val{:qr}; trunc = nothing, kwargs...)
+@inline function select_algorithm(::typeof(left_null!), A, ::Val{:qr}; trunc = nothing, kwargs...)
     isnothing(trunc) ||
         throw(ArgumentError("QR-based `left_null` is incompatible with specifying `trunc`"))
     alg = select_algorithm(qr_null!, A; kwargs...)
     return LeftNullViaQR(alg)
 end
-function select_algorithm(::typeof(left_null!), A, ::Val{:svd}; trunc = nothing, kwargs...)
+@inline function select_algorithm(::typeof(left_null!), A, ::Val{:svd}; trunc = nothing, kwargs...)
     alg_svd = select_algorithm(svd_full!, A, get(kwargs, :svd, nothing))
     alg = TruncatedAlgorithm(alg_svd, select_null_truncation(trunc))
     return LeftNullViaSVD(alg)
 end
 
-function select_algorithm(::typeof(right_null!), A, ::Val{:lq}; trunc = nothing, kwargs...)
+@inline function select_algorithm(::typeof(right_null!), A, ::Val{:lq}; trunc = nothing, kwargs...)
     isnothing(trunc) ||
         throw(ArgumentError("LQ-based `right_null` is incompatible with specifying `trunc`"))
     alg = select_algorithm(lq_null!, A; kwargs...)
     return RightNullViaLQ(alg)
 end
-function select_algorithm(::typeof(right_null!), A, ::Val{:svd}; trunc = nothing, kwargs...)
+@inline function select_algorithm(::typeof(right_null!), A, ::Val{:svd}; trunc = nothing, kwargs...)
     alg_svd = select_algorithm(svd_full!, A; kwargs...)
     alg = TruncatedAlgorithm(alg_svd, select_null_truncation(trunc))
     return RightNullViaSVD(alg)
 end
 
-default_algorithm(::typeof(left_orth!), ::Type{A}; trunc = nothing, kwargs...) where {A} =
+@inline default_algorithm(::typeof(left_orth!), ::Type{A}; trunc = nothing, kwargs...) where {A} =
     isnothing(trunc) ? select_algorithm(left_orth!, A, Val(:qr); kwargs...) :
     select_algorithm(left_orth!, A, Val(:svd); trunc, kwargs...)
 
-default_algorithm(::typeof(right_orth!), ::Type{A}; trunc = nothing, kwargs...) where {A} =
+@inline default_algorithm(::typeof(right_orth!), ::Type{A}; trunc = nothing, kwargs...) where {A} =
     isnothing(trunc) ? select_algorithm(right_orth!, A, Val(:lq); kwargs...) :
     select_algorithm(right_orth!, A, Val(:svd); trunc, kwargs...)
 
-default_algorithm(::typeof(left_null!), ::Type{A}; trunc = nothing, kwargs...) where {A} =
+@inline default_algorithm(::typeof(left_null!), ::Type{A}; trunc = nothing, kwargs...) where {A} =
     isnothing(trunc) ? select_algorithm(left_null!, A, Val(:qr); kwargs...) :
     select_algorithm(left_null!, A, Val(:svd); trunc, kwargs...)
 
-default_algorithm(::typeof(right_null!), ::Type{A}; trunc = nothing, kwargs...) where {A} =
+@inline default_algorithm(::typeof(right_null!), ::Type{A}; trunc = nothing, kwargs...) where {A} =
     isnothing(trunc) ? select_algorithm(right_null!, A, Val(:lq); kwargs...) :
     select_algorithm(right_null!, A, Val(:svd); trunc, kwargs...)
 

src/interface/qr.jl

@@ -71,8 +71,8 @@ See also [`lq_full(!)`](@ref lq_full) and [`lq_compact(!)`](@ref lq_compact).
 default_qr_algorithm(A; kwargs...) = default_qr_algorithm(typeof(A); kwargs...)
 
 default_qr_algorithm(T::Type; kwargs...) = throw(MethodError(default_qr_algorithm, (T,)))
-default_qr_algorithm(::Type{T}; driver = default_householder_driver(T), kwargs...) where {T <: AbstractMatrix} =
-    Householder(; driver, kwargs...)
+default_qr_algorithm(::Type{T}; kwargs...) where {T <: AbstractMatrix} =
+    Householder(; kwargs...)
 default_qr_algorithm(::Type{T}; kwargs...) where {T <: Diagonal} =
     DiagonalAlgorithm(; kwargs...)
 default_qr_algorithm(::Type{<:Base.ReshapedArray{T, N, A}}) where {T, N, A} =