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/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} =