diff --git a/Project.toml b/Project.toml
index 8a5f85c..ac30939 100644
--- a/Project.toml
+++ b/Project.toml
@@ -1,7 +1,7 @@
 name = "KroneckerArrays"
 uuid = "05d0b138-81bc-4ff7-84be-08becefb1ccc"
 authors = ["ITensor developers <support@itensor.org> and contributors"]
-version = "0.1.30"
+version = "0.2.0"
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
@@ -29,7 +29,7 @@ Adapt = "4.3"
 BlockArrays = "1.6"
 BlockSparseArrays = "0.9"
 DerivableInterfaces = "0.5.3"
-DiagonalArrays = "0.3.11"
+DiagonalArrays = "0.3.16"
 FillArrays = "1.13"
 GPUArraysCore = "0.2"
 LinearAlgebra = "1.10"
diff --git a/docs/Project.toml b/docs/Project.toml
index 0f09daa..5ce6ea9 100644
--- a/docs/Project.toml
+++ b/docs/Project.toml
@@ -6,4 +6,4 @@ KroneckerArrays = "05d0b138-81bc-4ff7-84be-08becefb1ccc"
 [compat]
 Documenter = "1"
 Literate = "2"
-KroneckerArrays = "0.1"
+KroneckerArrays = "0.2"
diff --git a/examples/Project.toml b/examples/Project.toml
index 0ef887a..ccb8779 100644
--- a/examples/Project.toml
+++ b/examples/Project.toml
@@ -2,4 +2,4 @@
 KroneckerArrays = "05d0b138-81bc-4ff7-84be-08becefb1ccc"
 
 [compat]
-KroneckerArrays = "0.1"
+KroneckerArrays = "0.2"
diff --git a/src/KroneckerArrays.jl b/src/KroneckerArrays.jl
index 4552a2f..9df32a8 100644
--- a/src/KroneckerArrays.jl
+++ b/src/KroneckerArrays.jl
@@ -8,7 +8,7 @@ include("linearalgebra.jl")
 include("matrixalgebrakit.jl")
 include("fillarrays/kroneckerarray.jl")
 include("fillarrays/linearalgebra.jl")
-include("fillarrays/matrixalgebrakit.jl")
-include("fillarrays/matrixalgebrakit_truncate.jl")
+# include("fillarrays/matrixalgebrakit.jl")
+# include("fillarrays/matrixalgebrakit_truncate.jl")
 
 end
diff --git a/src/kroneckerarray.jl b/src/kroneckerarray.jl
index bde7b33..3ae0d89 100644
--- a/src/kroneckerarray.jl
+++ b/src/kroneckerarray.jl
@@ -1,12 +1,18 @@
-# Allows customizing for `FillArrays.Eye`.
-function _convert(A::Type{<:AbstractArray}, a::AbstractArray)
-  return convert(A, a)
+function unwrap_array(a::AbstractArray)
+  p = parent(a)
+  p ≡ a && return a
+  return unwrap_array(p)
 end
+isactive(a::AbstractArray) = ismutable(unwrap_array(a))
+
 # Custom `_convert` works around the issue that
-# `convert(::Type{<:Diagonal}, ::AbstractMatrix)` isnt' defined
+# `convert(::Type{<:Diagonal}, ::AbstractMatrix)` isn't defined
 # in Julia v1.10 (https://github.com/JuliaLang/julia/pull/48895,
 # https://github.com/JuliaLang/julia/pull/52487).
 # TODO: Delete once we drop support for Julia v1.10.
+function _convert(A::Type{<:AbstractArray}, a::AbstractArray)
+  return convert(A, a)
+end
 using LinearAlgebra: LinearAlgebra, Diagonal, diag, isdiag
 _construct(A::Type{<:Diagonal}, a::AbstractMatrix) = A(diag(a))
 function _convert(A::Type{<:Diagonal}, a::AbstractMatrix)
@@ -25,7 +31,7 @@ function KroneckerArray(a::AbstractArray, b::AbstractArray)
     )
   end
   elt = promote_type(eltype(a), eltype(b))
-  return KroneckerArray(_convert(AbstractArray{elt}, a), _convert(AbstractArray{elt}, b))
+  return _convert(AbstractArray{elt}, a) ⊗ _convert(AbstractArray{elt}, b)
 end
 const KroneckerMatrix{T,A<:AbstractMatrix{T},B<:AbstractMatrix{T}} = KroneckerArray{T,2,A,B}
 const KroneckerVector{T,A<:AbstractVector{T},B<:AbstractVector{T}} = KroneckerArray{T,1,A,B}
@@ -33,70 +39,37 @@ const KroneckerVector{T,A<:AbstractVector{T},B<:AbstractVector{T}} = KroneckerAr
 arg1(a::KroneckerArray) = a.a
 arg2(a::KroneckerArray) = a.b
 
-using Adapt: Adapt, adapt
-_adapt(to, a::AbstractArray) = adapt(to, a)
-Adapt.adapt_structure(to, a::KroneckerArray) = _adapt(to, arg1(a)) ⊗ _adapt(to, arg2(a))
+function mutate_active_args!(f!, f, dest, src)
+  (isactive(arg1(dest)) || isactive(arg2(dest))) ||
+    error("Can't mutate immutable KroneckerArray.")
+  if isactive(arg1(dest))
+    f!(arg1(dest), arg1(src))
+  else
+    arg1(dest) == f(arg1(src)) || error("Immutable arguments aren't equal.")
+  end
+  if isactive(arg2(dest))
+    f!(arg2(dest), arg2(src))
+  else
+    arg2(dest) == f(arg2(src)) || error("Immutable arguments aren't equal.")
+  end
+  return dest
+end
 
-# Allows extra customization, like for `FillArrays.Eye`.
-_copy(a::AbstractArray) = copy(a)
+using Adapt: Adapt, adapt
+Adapt.adapt_structure(to, a::KroneckerArray) = adapt(to, arg1(a)) ⊗ adapt(to, arg2(a))
 
 function Base.copy(a::KroneckerArray)
-  return _copy(arg1(a)) ⊗ _copy(arg2(a))
-end
-
-# Allows extra customization, like for `FillArrays.Eye`.
-function _copyto!!(dest::AbstractArray{<:Any,N}, src::AbstractArray{<:Any,N}) where {N}
-  copyto!(dest, src)
-  return dest
-end
-using Base.Broadcast: Broadcasted
-function _copyto!!(dest::AbstractArray, src::Broadcasted)
-  copyto!(dest, src)
-  return dest
+  return copy(arg1(a)) ⊗ copy(arg2(a))
 end
 
 function Base.copyto!(dest::KroneckerArray{<:Any,N}, src::KroneckerArray{<:Any,N}) where {N}
-  return copyto!_kronecker(dest, src)
-end
-function copyto!_kronecker(
-  dest::KroneckerArray{<:Any,N}, src::KroneckerArray{<:Any,N}
-) where {N}
-  # TODO: Check if neither argument is mutated and if so error.
-  _copyto!!(arg1(dest), arg1(src))
-  _copyto!!(arg2(dest), arg2(src))
-  return dest
+  return mutate_active_args!(copyto!, copy, dest, src)
 end
 
 function Base.convert(::Type{KroneckerArray{T,N,A,B}}, a::KroneckerArray) where {T,N,A,B}
-  return KroneckerArray(_convert(A, arg1(a)), _convert(B, arg2(a)))
-end
-
-# Like `similar` but allows some custom behavior, such as for `FillArrays.Eye`.
-function _similar(a::AbstractArray, elt::Type, axs::Tuple)
-  return similar(a, elt, axs)
-end
-function _similar(a::AbstractArray, ax::Tuple)
-  return _similar(a, eltype(a), ax)
-end
-function _similar(a::AbstractArray, elt::Type)
-  return _similar(a, elt, axes(a))
-end
-function _similar(a::AbstractArray)
-  return _similar(a, eltype(a), axes(a))
-end
-function _similar(arrayt::Type{<:AbstractArray}, axs::Tuple)
-  return similar(arrayt, axs)
+  return _convert(A, arg1(a)) ⊗ _convert(B, arg2(a))
 end
 
-function Base.similar(
-  a::AbstractArray,
-  elt::Type,
-  axs::Tuple{
-    CartesianProductUnitRange{<:Integer},Vararg{CartesianProductUnitRange{<:Integer}}
-  },
-)
-  return _similar(a, elt, map(arg1, axs)) ⊗ _similar(a, elt, map(arg2, axs))
-end
 function Base.similar(
   a::KroneckerArray,
   elt::Type,
@@ -104,23 +77,46 @@ function Base.similar(
     CartesianProductUnitRange{<:Integer},Vararg{CartesianProductUnitRange{<:Integer}}
   },
 )
-  return _similar(arg1(a), elt, map(arg1, axs)) ⊗ _similar(arg2(a), elt, map(arg2, axs))
+  return similar(arg1(a), elt, map(arg1, axs)) ⊗ similar(arg2(a), elt, map(arg2, axs))
+end
+function Base.similar(a::KroneckerArray, elt::Type)
+  # TODO: Is this a good definition?
+  return if isactive(arg1(a)) == isactive(arg2(a))
+    similar(arg1(a), elt) ⊗ similar(arg2(a), elt)
+  elseif isactive(arg1(a))
+    similar(arg1(a), elt) ⊗ elt.(arg2(a))
+  elseif isactive(arg2(a))
+    elt.(arg1(a)) ⊗ similar(arg2(a), elt)
+  end
 end
+function Base.similar(a::KroneckerArray)
+  # TODO: Is this a good definition?
+  return if isactive(arg1(a)) == isactive(arg2(a))
+    similar(arg1(a)) ⊗ similar(arg2(a))
+  elseif isactive(arg1(a))
+    similar(arg1(a)) ⊗ arg2(a)
+  elseif isactive(arg2(a))
+    arg1(a) ⊗ similar(arg2(a))
+  end
+end
+
 function Base.similar(
-  arrayt::Type{<:AbstractArray},
+  a::AbstractArray,
+  elt::Type,
   axs::Tuple{
     CartesianProductUnitRange{<:Integer},Vararg{CartesianProductUnitRange{<:Integer}}
   },
 )
-  return _similar(arrayt, map(arg1, axs)) ⊗ _similar(arrayt, map(arg2, axs))
+  return similar(a, elt, map(arg1, axs)) ⊗ similar(a, elt, map(arg2, axs))
 end
+
 function Base.similar(
   arrayt::Type{<:KroneckerArray{<:Any,<:Any,A,B}},
   axs::Tuple{
     CartesianProductUnitRange{<:Integer},Vararg{CartesianProductUnitRange{<:Integer}}
   },
 ) where {A,B}
-  return _similar(A, map(arg1, axs)) ⊗ _similar(B, map(arg2, axs))
+  return similar(A, map(arg1, axs)) ⊗ similar(B, map(arg2, axs))
 end
 function Base.similar(
   ::Type{<:KroneckerArray{<:Any,<:Any,A,B}}, sz::Tuple{Int,Vararg{Int}}
@@ -128,21 +124,27 @@ function Base.similar(
   return similar(promote_type(A, B), sz)
 end
 
-function _permutedims!!(dest::AbstractArray, src::AbstractArray, perm)
-  permutedims!(dest, src, perm)
-  return dest
+function Base.similar(
+  arrayt::Type{<:AbstractArray},
+  axs::Tuple{
+    CartesianProductUnitRange{<:Integer},Vararg{CartesianProductUnitRange{<:Integer}}
+  },
+)
+  return similar(arrayt, map(arg1, axs)) ⊗ similar(arrayt, map(arg2, axs))
 end
 
+function Base.permutedims(a::KroneckerArray, perm)
+  return permutedims(arg1(a), perm) ⊗ permutedims(arg2(a), perm)
+end
 using DerivableInterfaces: DerivableInterfaces, permuteddims
 function DerivableInterfaces.permuteddims(a::KroneckerArray, perm)
   return permuteddims(arg1(a), perm) ⊗ permuteddims(arg2(a), perm)
 end
 
 function Base.permutedims!(dest::KroneckerArray, src::KroneckerArray, perm)
-  # TODO: Error if neither argument is mutable.
-  _permutedims!!(arg1(dest), arg1(src), perm)
-  _permutedims!!(arg2(dest), arg2(src), perm)
-  return dest
+  return mutate_active_args!(
+    (dest, src) -> permutedims!(dest, src, perm), Base.Fix2(permutedims, perm), dest, src
+  )
 end
 
 function flatten(t::Tuple{Tuple,Tuple,Vararg{Tuple}})
@@ -172,15 +174,24 @@ kron_nd(a::AbstractVector, b::AbstractVector) = kron(a, b)
 # Eagerly collect arguments to make more general on GPU.
 Base.collect(a::KroneckerArray) = kron_nd(collect(arg1(a)), collect(arg2(a)))
 
-Base.zero(a::KroneckerArray) = zero(arg1(a)) ⊗ zero(arg2(a))
+function Base.zero(a::KroneckerArray)
+  return if isactive(arg1(a)) == isactive(arg2(a))
+    # TODO: Maybe this should zero both arguments?
+    # This is how `a * false` would behave.
+    arg1(a) ⊗ zero(arg2(a))
+  elseif isactive(arg1(a))
+    zero(arg1(a)) ⊗ arg2(a)
+  elseif isactive(arg2(a))
+    arg1(a) ⊗ zero(arg2(a))
+  end
+end
 
 using DerivableInterfaces: DerivableInterfaces, zero!
 function DerivableInterfaces.zero!(a::KroneckerArray)
-  ismut1 = ismutable(arg1(a))
-  ismut2 = ismutable(arg2(a))
-  (ismut1 || ismut2) || throw(ArgumentError("Can't zero out immutable KroneckerArray."))
-  ismut1 && zero!(arg1(a))
-  ismut2 && zero!(arg2(a))
+  (isactive(arg1(a)) || isactive(arg2(a))) ||
+    error("Can't mutate immutable KroneckerArray.")
+  isactive(arg1(a)) && zero!(arg1(a))
+  isactive(arg2(a)) && zero!(arg2(a))
   return a
 end
 
@@ -245,19 +256,15 @@ function Base.to_indices(
   return I1 .× I2
 end
 
-# Allow customizing for `FillArrays.Eye`.
-_getindex(a::AbstractArray, I...) = a[I...]
 function Base.getindex(
   a::KroneckerArray{<:Any,N}, I::Vararg{Union{CartesianPair,CartesianProduct},N}
 ) where {N}
   I′ = to_indices(a, I)
-  return _getindex(arg1(a), arg1.(I′)...) ⊗ _getindex(arg2(a), arg2.(I′)...)
+  return arg1(a)[arg1.(I′)...] ⊗ arg2(a)[arg2.(I′)...]
 end
 # Fix ambigiuity error.
 Base.getindex(a::KroneckerArray{<:Any,0}) = arg1(a)[] * arg2(a)[]
 
-# Allow customizing for `FillArrays.Eye`.
-_view(a::AbstractArray, I...) = view(a, I...)
 arg1(::Colon) = (:)
 arg2(::Colon) = (:)
 arg1(::Base.Slice) = (:)
@@ -266,13 +273,13 @@ function Base.view(
   a::KroneckerArray{<:Any,N},
   I::Vararg{Union{CartesianProduct,CartesianProductUnitRange,Base.Slice,Colon},N},
 ) where {N}
-  return _view(arg1(a), arg1.(I)...) ⊗ _view(arg2(a), arg2.(I)...)
+  return view(arg1(a), arg1.(I)...) ⊗ view(arg2(a), arg2.(I)...)
 end
 function Base.view(a::KroneckerArray{<:Any,N}, I::Vararg{CartesianPair,N}) where {N}
-  return _view(arg1(a), arg1.(I)...) ⊗ _view(arg2(a), arg2.(I)...)
+  return view(arg1(a), arg1.(I)...) ⊗ view(arg2(a), arg2.(I)...)
 end
 # Fix ambigiuity error.
-Base.view(a::KroneckerArray{<:Any,0}) = _view(arg1(a)) * _view(arg2(a))
+Base.view(a::KroneckerArray{<:Any,0}) = view(arg1(a)) ⊗ view(arg2(a))
 
 function Base.:(==)(a::KroneckerArray, b::KroneckerArray)
   return arg1(a) == arg1(b) && arg2(a) == arg2(b)
@@ -297,7 +304,7 @@ function Base.real(a::KroneckerArray)
   if iszero(imag(arg1(a))) || iszero(imag(arg2(a)))
     return real(arg1(a)) ⊗ real(arg2(a))
   elseif iszero(real(arg1(a))) || iszero(real(arg2(a)))
-    return -imag(arg1(a)) ⊗ imag(arg2(a))
+    return -(imag(arg1(a)) ⊗ imag(arg2(a)))
   end
   return real(arg1(a)) ⊗ real(arg2(a)) - imag(arg1(a)) ⊗ imag(arg2(a))
 end
@@ -325,9 +332,6 @@ function Base.reshape(
   return reshape(arg1(a), map(arg1, ax)) ⊗ reshape(arg2(a), map(arg2, ax))
 end
 
-# Allows for customizations for FillArrays.
-_BroadcastStyle(x) = BroadcastStyle(x)
-
 using Base.Broadcast: Broadcast, AbstractArrayStyle, BroadcastStyle, Broadcasted
 struct KroneckerStyle{N,A,B} <: AbstractArrayStyle{N} end
 arg1(::Type{<:KroneckerStyle{<:Any,A}}) where {A} = A
@@ -344,7 +348,7 @@ function KroneckerStyle{N,A,B}(v::Val{M}) where {N,A,B,M}
   return KroneckerStyle{M,typeof(A)(v),typeof(B)(v)}()
 end
 function Base.BroadcastStyle(::Type{<:KroneckerArray{<:Any,N,A,B}}) where {N,A,B}
-  return KroneckerStyle{N}(_BroadcastStyle(A), _BroadcastStyle(B))
+  return KroneckerStyle{N}(BroadcastStyle(A), BroadcastStyle(B))
 end
 function Base.BroadcastStyle(style1::KroneckerStyle{N}, style2::KroneckerStyle{N}) where {N}
   style_a = BroadcastStyle(arg1(style1), arg1(style2))
@@ -370,23 +374,34 @@ function Base.map!(f, dest::KroneckerArray, a1::KroneckerArray, a_rest::Kronecke
 end
 
 using MapBroadcast: MapBroadcast, LinearCombination, Summed
-function Base.copyto!(dest::KroneckerArray, a::Summed{<:KroneckerStyle})
-  dest1 = arg1(dest)
-  dest2 = arg2(dest)
+function KroneckerBroadcast(a::Summed{<:KroneckerStyle})
   f = LinearCombination(a)
   args = MapBroadcast.arguments(a)
   arg1s = arg1.(args)
   arg2s = arg2.(args)
-  if allequal(arg2s)
-    copyto!(dest2, first(arg2s))
-    dest1 .= f.(arg1s...)
-  elseif allequal(arg1s)
-    copyto!(dest1, first(arg1s))
-    dest2 .= f.(arg2s...)
-  else
+  arg1_isunique = allequal(arg1s)
+  arg2_isunique = allequal(arg2s)
+  (arg1_isunique || arg2_isunique) ||
     error("This operation doesn't preserve the Kronecker structure.")
+  broadcast_arg = if arg1_isunique && arg2_isunique
+    isactive(first(arg1s)) ? 1 : 2
+  elseif arg1_isunique
+    2
+  elseif arg2_isunique
+    1
+  end
+  return if broadcast_arg == 1
+    broadcasted(f, arg1s...) ⊗ first(arg2s)
+  elseif broadcast_arg == 2
+    first(arg1s) ⊗ broadcasted(f, arg2s...)
   end
-  return dest
+end
+
+function Base.copy(a::Summed{<:KroneckerStyle})
+  return copy(KroneckerBroadcast(a))
+end
+function Base.copyto!(dest::KroneckerArray, a::Summed{<:KroneckerStyle})
+  return copyto!(dest, KroneckerBroadcast(a))
 end
 
 function Broadcast.broadcasted(::KroneckerStyle, f, as...)
@@ -428,11 +443,31 @@ function Broadcast.broadcasted(style::KroneckerStyle, f::Base.Fix2{typeof(/),<:N
   return broadcasted(style, /, a, f.x)
 end
 
+# Compatibility with MapBroadcast.jl.
+using MapBroadcast: MapBroadcast, MapFunction
+function Base.broadcasted(
+  style::KroneckerStyle, f::MapFunction{typeof(*),<:Tuple{<:Number,MapBroadcast.Arg}}, a
+)
+  return broadcasted(style, *, f.args[1], a)
+end
+function Base.broadcasted(
+  style::KroneckerStyle, f::MapFunction{typeof(*),<:Tuple{MapBroadcast.Arg,<:Number}}, a
+)
+  return broadcasted(style, *, a, f.args[2])
+end
+function Base.broadcasted(
+  style::KroneckerStyle, f::MapFunction{typeof(/),<:Tuple{MapBroadcast.Arg,<:Number}}, a
+)
+  return broadcasted(style, /, a, f.args[2])
+end
 # Use to determine the element type of KroneckerBroadcasted.
 _eltype(x) = eltype(x)
 _eltype(x::Broadcasted) = Base.promote_op(x.f, _eltype.(x.args)...)
 
 using Base.Broadcast: broadcasted
+# Represents broadcast operations that can be applied Kronecker-wise,
+# i.e. independently to each argument of the Kronecker product.
+# Note that not all broadcast operations can be mapped to this.
 struct KroneckerBroadcasted{A,B}
   a::A
   b::B
@@ -446,10 +481,8 @@ Broadcast.materialize(a::KroneckerBroadcasted) = copy(a)
 Broadcast.materialize!(dest, a::KroneckerBroadcasted) = copyto!(dest, a)
 Broadcast.broadcastable(a::KroneckerBroadcasted) = a
 Base.copy(a::KroneckerBroadcasted) = copy(arg1(a)) ⊗ copy(arg2(a))
-function Base.copyto!(dest::KroneckerArray, a::KroneckerBroadcasted)
-  _copyto!!(arg1(dest), arg1(a))
-  _copyto!!(arg2(dest), arg2(a))
-  return dest
+function Base.copyto!(dest::KroneckerArray, src::KroneckerBroadcasted)
+  return mutate_active_args!(copyto!, copy, dest, src)
 end
 function Base.eltype(a::KroneckerBroadcasted)
   a1 = arg1(a)
@@ -478,21 +511,3 @@ for f in [:identity, :conj]
     end
   end
 end
-
-# Compatibility with MapBroadcast.jl.
-using MapBroadcast: MapBroadcast, MapFunction
-function Base.broadcasted(
-  style::KroneckerStyle, f::MapFunction{typeof(*),<:Tuple{<:Number,MapBroadcast.Arg}}, a
-)
-  return broadcasted(style, *, f.args[1], a)
-end
-function Base.broadcasted(
-  style::KroneckerStyle, f::MapFunction{typeof(*),<:Tuple{MapBroadcast.Arg,<:Number}}, a
-)
-  return broadcasted(style, *, a, f.args[2])
-end
-function Base.broadcasted(
-  style::KroneckerStyle, f::MapFunction{typeof(/),<:Tuple{MapBroadcast.Arg,<:Number}}, a
-)
-  return broadcasted(style, /, a, f.args[2])
-end
diff --git a/src/linearalgebra.jl b/src/linearalgebra.jl
index aaf3e06..a82e427 100644
--- a/src/linearalgebra.jl
+++ b/src/linearalgebra.jl
@@ -30,7 +30,7 @@ function LinearAlgebra.pinv(a::KroneckerArray; kwargs...)
 end
 
 function LinearAlgebra.diag(a::KroneckerArray)
-  return copy(diagview(a))
+  return copy(DiagonalArrays.diagview(a))
 end
 
 # Allows customizing multiplication for specific types
diff --git a/src/linearcombination.jl b/src/linearcombination.jl
deleted file mode 100644
index 352d135..0000000
--- a/src/linearcombination.jl
+++ /dev/null
@@ -1,92 +0,0 @@
-using Base.Broadcast: Broadcasted
-struct LinearCombination{C} <: Function
-  coefficients::C
-end
-coefficients(a::LinearCombination) = a.coefficients
-function (f::LinearCombination)(args...)
-  return mapreduce(*,+,coefficients(f),args)
-end
-
-struct Sum{Style,C<:Tuple,A<:Tuple}
-  style::Style
-  coefficients::C
-  arguments::A
-end
-coefficients(a::Sum) = a.coefficients
-arguments(a::Sum) = a.arguments
-style(a::Sum) = a.style
-LinearCombination(a::Sum) = LinearCombination(coefficients(a))
-using Base.Broadcast: combine_axes
-Base.axes(a::Sum) = combine_axes(a.arguments...)
-function Base.eltype(a::Sum)
-  cts = typeof.(coefficients(a))
-  elts = eltype.(arguments(a))
-  ts = map((ct, elt) -> Base.promote_op(*, ct, elt), cts, elts)
-  return Base.promote_op(+, ts...)
-end
-using Base.Broadcast: combine_styles
-function Sum(coefficients::Tuple, arguments::Tuple)
-  return Sum(combine_styles(arguments...), coefficients, arguments)
-end
-Sum(a) = Sum((one(eltype(a)),), (a,))
-function Base.:+(a::Sum, b::Sum)
-  return Sum((coefficients(a)..., coefficients(b)...), (arguments(a)..., arguments(b)...))
-end
-Base.:-(a::Sum, b::Sum) = a + (-b)
-Base.:+(a::Sum, b::AbstractArray) = a + Sum(b)
-Base.:-(a::Sum, b::AbstractArray) = a - Sum(b)
-Base.:+(a::AbstractArray, b::Sum) = Sum(a) + b
-Base.:-(a::AbstractArray, b::Sum) = Sum(a) - b
-Base.:*(c::Number, a::Sum) = Sum(c .* coefficients(a), arguments(a))
-Base.:*(a::Sum, c::Number) = c * a
-Base.:/(a::Sum, c::Number) = Sum(coefficients(a) ./ c, arguments(a))
-Base.:-(a::Sum) = -1 * a
-
-function Base.copy(a::Sum)
-  return copyto!(similar(a), a)
-end
-Base.similar(a::Sum) = similar(a, eltype(a))
-Base.similar(a::Sum, elt::Type) = similar(a, elt, axes(a))
-function Base.copyto!(dest::AbstractArray, a::Sum)
-  f = LinearCombination(a)
-  dest .= f.(arguments(a)...)
-  return dest
-end
-function Broadcast.Broadcasted(a::Sum)
-  f = LinearCombination(a)
-  return Broadcasted(style(a), f, arguments(a), axes(a))
-end
-function Base.similar(a::Sum, elt::Type, ax::Tuple)
-  return similar(Broadcasted(a), elt, ax)
-end
-
-using Base.Broadcast: Broadcast, AbstractArrayStyle, DefaultArrayStyle
-Broadcast.materialize(a::Sum) = copy(a)
-Broadcast.materialize!(dest, a::Sum) = copyto!(dest, a)
-struct SumStyle <: AbstractArrayStyle{Any} end
-Broadcast.broadcastable(a::Sum) = a
-Broadcast.BroadcastStyle(::Type{<:Sum}) = SumStyle()
-Broadcast.BroadcastStyle(style::SumStyle, ::AbstractArrayStyle) = style
-# Fix ambiguity error with Base.
-Broadcast.BroadcastStyle(style::SumStyle, ::DefaultArrayStyle) = style
-function Broadcast.broadcasted(::SumStyle, f, as...)
-  return error("Arbitrary broadcasting not supported for SumStyle.")
-end
-function Broadcast.broadcasted(::SumStyle, ::typeof(+), a, b::Sum)
-  return Sum(a) + b
-end
-function Broadcast.broadcasted(::SumStyle, ::typeof(+), a::Sum, b)
-  return a + Sum(b)
-end
-function Broadcast.broadcasted(::SumStyle, ::typeof(+), a::Sum, b::Sum)
-  return a + b
-end
-function Broadcast.broadcasted(::SumStyle, ::typeof(*), c::Number, a)
-  return c * Sum(a)
-end
-function Broadcast.broadcasted(::SumStyle, ::typeof(*), c::Number, a::Sum)
-  return c * a
-end
-function Broadcast.broadcasted(::SumStyle, ::typeof(/), a::Sum, c::Number)
-  return Sum(a) / c
-end
diff --git a/src/matrixalgebrakit.jl b/src/matrixalgebrakit.jl
index 7e88608..b4ce206 100644
--- a/src/matrixalgebrakit.jl
+++ b/src/matrixalgebrakit.jl
@@ -9,39 +9,60 @@ using MatrixAlgebraKit:
   default_qr_algorithm,
   default_svd_algorithm,
   eig_full!,
+  eig_full,
   eig_trunc!,
+  eig_trunc,
   eig_vals!,
+  eig_vals,
   eigh_full!,
+  eigh_full,
   eigh_trunc!,
+  eigh_trunc,
   eigh_vals!,
+  eigh_vals,
   initialize_output,
   left_null!,
+  left_null,
   left_orth!,
+  left_orth,
   left_polar!,
+  left_polar,
   lq_compact!,
+  lq_compact,
   lq_full!,
+  lq_full,
   qr_compact!,
+  qr_compact,
   qr_full!,
+  qr_full,
   right_null!,
+  right_null,
   right_orth!,
+  right_orth,
   right_polar!,
+  right_polar,
   svd_compact!,
+  svd_compact,
   svd_full!,
+  svd_full,
   svd_trunc!,
+  svd_trunc,
   svd_vals!,
+  svd_vals,
   truncate!
 
-using MatrixAlgebraKit: MatrixAlgebraKit, diagview
-# Allow customization for `Eye`.
-_diagview(a::AbstractMatrix) = diagview(a)
-function MatrixAlgebraKit.diagview(a::KroneckerMatrix)
-  return _diagview(a.a) ⊗ _diagview(a.b)
+using DiagonalArrays: DiagonalArrays, diagview
+function DiagonalArrays.diagview(a::KroneckerMatrix)
+  return diagview(arg1(a)) ⊗ diagview(arg2(a))
 end
+MatrixAlgebraKit.diagview(a::KroneckerMatrix) = diagview(a)
 
 struct KroneckerAlgorithm{A,B} <: AbstractAlgorithm
-  a::A
-  b::B
+  arg1::A
+  arg2::B
 end
+arg1(alg::KroneckerAlgorithm) = alg.arg1
+arg2(alg::KroneckerAlgorithm) = alg.arg2
 
 using MatrixAlgebraKit:
   copy_input,
@@ -62,10 +83,6 @@ using MatrixAlgebraKit:
   svd_compact,
   svd_full
 
-function _copy_input(f::F, a::AbstractMatrix) where {F}
-  return copy_input(f, a)
-end
-
 for f in [
   :eig_full,
   :eigh_full,
@@ -80,7 +97,7 @@ for f in [
 ]
   @eval begin
     function MatrixAlgebraKit.copy_input(::typeof($f), a::KroneckerMatrix)
-      return _copy_input($f, a.a) ⊗ _copy_input($f, a.b)
+      return copy_input($f, arg1(a)) ⊗ copy_input($f, arg2(a))
     end
   end
 end
@@ -93,105 +110,179 @@ for f in [
   :default_polar_algorithm,
   :default_svd_algorithm,
 ]
-  _f = Symbol(:_, f)
   @eval begin
-    function $_f(A::Type{<:AbstractMatrix}; kwargs...)
-      return $f(A; kwargs...)
-    end
     function MatrixAlgebraKit.$f(
       A::Type{<:KroneckerMatrix}; kwargs1=(;), kwargs2=(;), kwargs...
     )
       A1, A2 = argument_types(A)
       return KroneckerAlgorithm(
-        $_f(A1; kwargs..., kwargs1...), $_f(A2; kwargs..., kwargs2...)
+        $f(A1; kwargs..., kwargs1...), $f(A2; kwargs..., kwargs2...)
       )
     end
   end
 end
 
-# TODO: Delete this once https://github.com/QuantumKitHub/MatrixAlgebraKit.jl/pull/32 is merged.
-function MatrixAlgebraKit.default_algorithm(
-  ::typeof(qr_compact!), A::Type{<:KroneckerMatrix}; kwargs...
-)
-  return default_qr_algorithm(A; kwargs...)
-end
-# TODO: Delete this once https://github.com/QuantumKitHub/MatrixAlgebraKit.jl/pull/32 is merged.
-function MatrixAlgebraKit.default_algorithm(
-  ::typeof(qr_full!), A::Type{<:KroneckerMatrix}; kwargs...
-)
-  return default_qr_algorithm(A; kwargs...)
-end
-
-# Allows overloading while avoiding type piracy.
-function _initialize_output(f::F, a::AbstractMatrix, alg::AbstractAlgorithm) where {F}
-  return initialize_output(f, a, alg)
-end
-_initialize_output(f::F, a::AbstractMatrix) where {F} = initialize_output(f, a)
-
 for f in [
-  :eig_full!,
-  :eigh_full!,
-  :qr_compact!,
-  :qr_full!,
-  :left_polar!,
-  :lq_compact!,
-  :lq_full!,
-  :right_polar!,
-  :svd_compact!,
-  :svd_full!,
+  :eig_full,
+  :eigh_full,
+  :left_polar,
+  :lq_compact,
+  :lq_full,
+  :qr_compact,
+  :qr_full,
+  :right_polar,
+  :svd_compact,
+  :svd_full,
 ]
+  f! = Symbol(f, :!)
   @eval begin
-    function MatrixAlgebraKit.initialize_output(
-      ::typeof($f), a::KroneckerMatrix, alg::KroneckerAlgorithm
-    )
-      return _initialize_output($f, a.a, alg.a) .⊗ _initialize_output($f, a.b, alg.b)
+    function MatrixAlgebraKit.initialize_output(::typeof($f!), a, alg::KroneckerAlgorithm)
+      return nothing
     end
-    function MatrixAlgebraKit.$f(
+    function MatrixAlgebraKit.$f!(
       a::KroneckerMatrix, F, alg::KroneckerAlgorithm; kwargs1=(;), kwargs2=(;), kwargs...
     )
-      $f(a.a, Base.Fix2(getfield, :a).(F), alg.a; kwargs..., kwargs1...)
-      $f(a.b, Base.Fix2(getfield, :b).(F), alg.b; kwargs..., kwargs2...)
-      return F
+      a1 = $f(arg1(a), arg1(alg); kwargs..., kwargs1...)
+      a2 = $f(arg2(a), arg2(alg); kwargs..., kwargs2...)
+      return a1 .⊗ a2
     end
   end
 end
 
-for f in [:eig_vals!, :eigh_vals!, :svd_vals!]
+for f in [:eig_vals, :eigh_vals, :svd_vals]
+  f! = Symbol(f, :!)
   @eval begin
-    function MatrixAlgebraKit.initialize_output(
-      ::typeof($f), a::KroneckerMatrix, alg::KroneckerAlgorithm
-    )
-      return _initialize_output($f, a.a, alg.a) ⊗ _initialize_output($f, a.b, alg.b)
+    function MatrixAlgebraKit.initialize_output(::typeof($f!), a, alg::KroneckerAlgorithm)
+      return nothing
     end
-    function MatrixAlgebraKit.$f(a::KroneckerMatrix, F, alg::KroneckerAlgorithm)
-      $f(a.a, F.a, alg.a)
-      $f(a.b, F.b, alg.b)
-      return F
+    function MatrixAlgebraKit.$f!(
+      a::KroneckerMatrix, F, alg::KroneckerAlgorithm; kwargs1=(;), kwargs2=(;), kwargs...
+    )
+      a1 = $f(arg1(a), arg1(alg); kwargs..., kwargs1...)
+      a2 = $f(arg2(a), arg2(alg); kwargs..., kwargs2...)
+      return a1 ⊗ a2
     end
   end
 end
 
-for f in [:left_orth!, :right_orth!]
+for f in [:left_orth, :right_orth]
+  f! = Symbol(f, :!)
   @eval begin
-    function MatrixAlgebraKit.initialize_output(::typeof($f), a::KroneckerMatrix)
-      return _initialize_output($f, a.a) .⊗ _initialize_output($f, a.b)
+    function MatrixAlgebraKit.initialize_output(::typeof($f!), a::KroneckerMatrix)
+      return nothing
+    end
+    function MatrixAlgebraKit.$f!(
+      a::KroneckerMatrix, F; kwargs1=(;), kwargs2=(;), kwargs...
+    )
+      a1 = $f(arg1(a); kwargs..., kwargs1...)
+      a2 = $f(arg2(a); kwargs..., kwargs2...)
+      return a1 .⊗ a2
     end
   end
 end
 
-for f in [:left_null!, :right_null!]
-  _f = Symbol(:_, f)
+for f in [:left_null, :right_null]
+  f! = Symbol(f, :!)
   @eval begin
     function MatrixAlgebraKit.initialize_output(::typeof($f), a::KroneckerMatrix)
-      return _initialize_output($f, a.a) ⊗ _initialize_output($f, a.b)
+      return nothing
     end
-    function $_f(a::AbstractMatrix, F; kwargs...)
-      return $f(a, F; kwargs...)
+    function MatrixAlgebraKit.$f!(
+      a::KroneckerMatrix, F; kwargs1=(;), kwargs2=(;), kwargs...
+    )
+      a1 = $f(arg1(a); kwargs..., kwargs1...)
+      a2 = $f(arg2(a); kwargs..., kwargs2...)
+      return a1 ⊗ a2
+    end
+  end
+end
+
+# Truncation
+
+using MatrixAlgebraKit: TruncationStrategy, findtruncated, truncate!
+
+struct KroneckerTruncationStrategy{T<:TruncationStrategy} <: TruncationStrategy
+  strategy::T
+end
+
+## # Avoid instantiating the identity.
+## function Base.getindex(a::EyeKronecker, I::Vararg{CartesianProduct{Colon},2})
+##   return a.a ⊗ a.b[I[1].b, I[2].b]
+## end
+## function Base.getindex(a::KroneckerEye, I::Vararg{CartesianProduct{<:Any,Colon},2})
+##   return a.a[I[1].a, I[2].a] ⊗ a.b
+## end
+## function Base.getindex(a::EyeEye, I::Vararg{CartesianProduct{Colon,Colon},2})
+##   return a
+## end
+
+## using FillArrays: OnesVector
+## const OnesKroneckerVector{T,A<:OnesVector{T},B<:AbstractVector{T}} = KroneckerVector{T,A,B}
+## const KroneckerOnesVector{T,A<:AbstractVector{T},B<:OnesVector{T}} = KroneckerVector{T,A,B}
+## const OnesVectorOnesVector{T,A<:OnesVector{T},B<:OnesVector{T}} = KroneckerVector{T,A,B}
+
+axis(a) = only(axes(a))
+
+## # Convert indices determined with a generic call to `findtruncated` to indices
+## # more suited for a KroneckerVector.
+## function to_truncated_indices(values::OnesKroneckerVector, I)
+##   prods = cartesianproduct(axis(values))[I]
+##   I_id = only(to_indices(arg1(values), (:,)))
+##   I_data = unique(arg2.(prods))
+##   # Drop truncations that occur within the identity.
+##   I_data = filter(I_data) do i
+##     return count(x -> arg2(x) == i, prods) == length(arg2(values))
+##   end
+##   return I_id × I_data
+## end
+## function to_truncated_indices(values::KroneckerOnesVector, I)
+##   #I = findtruncated(Vector(values), strategy.strategy)
+##   prods = cartesianproduct(axis(values))[I]
+##   I_data = unique(arg1.(prods))
+##   # Drop truncations that occur within the identity.
+##   I_data = filter(I_data) do i
+##     return count(x -> arg1(x) == i, prods) == length(arg2(values))
+##   end
+##   I_id = only(to_indices(arg2(values), (:,)))
+##   return I_data × I_id
+## end
+function to_truncated_indices(values::KroneckerVector, I)
+  return throw(ArgumentError("Not implemented"))
+end
+
+function MatrixAlgebraKit.findtruncated(
+  values::KroneckerVector, strategy::KroneckerTruncationStrategy
+)
+  I = findtruncated(Vector(values), strategy.strategy)
+  return to_truncated_indices(values, I)
+end
+
+for f in [:eig_trunc!, :eigh_trunc!]
+  @eval begin
+    function MatrixAlgebraKit.truncate!(
+      ::typeof($f), DV::NTuple{2,KroneckerMatrix}, strategy::TruncationStrategy
+    )
+      return truncate!($f, DV, KroneckerTruncationStrategy(strategy))
     end
-    function MatrixAlgebraKit.$f(a::KroneckerMatrix, F; kwargs1=(;), kwargs2=(;), kwargs...)
-      $_f(a.a, F.a; kwargs..., kwargs1...)
-      $_f(a.b, F.b; kwargs..., kwargs2...)
-      return F
+    function MatrixAlgebraKit.truncate!(
+      ::typeof($f), (D, V)::NTuple{2,KroneckerMatrix}, strategy::KroneckerTruncationStrategy
+    )
+      I = findtruncated(diagview(D), strategy)
+      return (D[I, I], V[(:) × (:), I])
     end
   end
 end
+
+function MatrixAlgebraKit.truncate!(
+  f::typeof(svd_trunc!), USVᴴ::NTuple{3,KroneckerMatrix}, strategy::TruncationStrategy
+)
+  return truncate!(f, USVᴴ, KroneckerTruncationStrategy(strategy))
+end
+function MatrixAlgebraKit.truncate!(
+  ::typeof(svd_trunc!),
+  (U, S, Vᴴ)::NTuple{3,KroneckerMatrix},
+  strategy::KroneckerTruncationStrategy,
+)
+  I = findtruncated(diagview(S), strategy)
+  return (U[(:) × (:), I], S[I, I], Vᴴ[I, (:) × (:)])
+end
diff --git a/test/Project.toml b/test/Project.toml
index f37978a..1a4e0fe 100644
--- a/test/Project.toml
+++ b/test/Project.toml
@@ -29,7 +29,7 @@ DiagonalArrays = "0.3.7"
 FillArrays = "1"
 GPUArraysCore = "0.2"
 JLArrays = "0.2"
-KroneckerArrays = "0.1"
+KroneckerArrays = "0.2"
 LinearAlgebra = "1.10"
 MatrixAlgebraKit = "0.2"
 SafeTestsets = "0.1"
diff --git a/test/test_blocksparsearrays.jl b/test/test_blocksparsearrays.jl
deleted file mode 100644
index db492db..0000000
--- a/test/test_blocksparsearrays.jl
+++ /dev/null
@@ -1,324 +0,0 @@
-using Adapt: adapt
-using BlockArrays: Block, BlockRange, blockedrange, blockisequal, mortar
-using BlockSparseArrays:
-  BlockIndexVector,
-  BlockSparseArray,
-  BlockSparseMatrix,
-  blockrange,
-  blocksparse,
-  blocktype,
-  eachblockaxis
-using FillArrays: Eye, SquareEye
-using JLArrays: JLArray
-using KroneckerArrays: KroneckerArray, ⊗, ×, arg1, arg2, cartesianrange
-using LinearAlgebra: norm
-using MatrixAlgebraKit: svd_compact, svd_trunc
-using StableRNGs: StableRNG
-using Test: @test, @test_broken, @testset
-using TestExtras: @constinferred
-
-elts = (Float32, Float64, ComplexF32)
-arrayts = (Array, JLArray)
-@testset "BlockSparseArraysExt, KroneckerArray blocks (arraytype=$arrayt, eltype=$elt)" for arrayt in
-                                                                                            arrayts,
-  elt in elts
-
-  # BlockUnitRange with CartesianProduct blocks
-  r = blockrange([2 × 3, 3 × 4])
-  @test r[Block(1)] ≡ cartesianrange(2 × 3, 1:6)
-  @test r[Block(2)] ≡ cartesianrange(3 × 4, 7:18)
-  @test eachblockaxis(r)[1] ≡ cartesianrange(2, 3)
-  @test eachblockaxis(r)[2] ≡ cartesianrange(3, 4)
-  @test blockisequal(arg1(r), blockedrange([2, 3]))
-  @test blockisequal(arg2(r), blockedrange([3, 4]))
-
-  dev = adapt(arrayt)
-  r = blockrange([2 × 2, 3 × 3])
-  d = Dict(
-    Block(1, 1) => dev(randn(elt, 2, 2) ⊗ randn(elt, 2, 2)),
-    Block(2, 2) => dev(randn(elt, 3, 3) ⊗ randn(elt, 3, 3)),
-  )
-  a = dev(blocksparse(d, (r, r)))
-  @test sprint(show, a) isa String
-  @test sprint(show, MIME("text/plain"), a) isa String
-  @test blocktype(a) === valtype(d)
-  @test a isa BlockSparseMatrix{elt,valtype(d)}
-  @test a[Block(1, 1)] == dev(d[Block(1, 1)])
-  @test a[Block(1, 1)] isa valtype(d)
-  @test a[Block(2, 2)] == dev(d[Block(2, 2)])
-  @test a[Block(2, 2)] isa valtype(d)
-  @test iszero(a[Block(2, 1)])
-  @test a[Block(2, 1)] == dev(zeros(elt, 3, 2) ⊗ zeros(elt, 3, 2))
-  @test a[Block(2, 1)] isa valtype(d)
-  @test iszero(a[Block(1, 2)])
-  @test a[Block(1, 2)] == dev(zeros(elt, 2, 3) ⊗ zeros(elt, 2, 3))
-  @test a[Block(1, 2)] isa valtype(d)
-
-  # Slicing
-  r = blockrange([2 × 2, 3 × 3])
-  d = Dict(
-    Block(1, 1) => dev(randn(elt, 2, 2) ⊗ randn(elt, 2, 2)),
-    Block(2, 2) => dev(randn(elt, 3, 3) ⊗ randn(elt, 3, 3)),
-  )
-  a = dev(blocksparse(d, (r, r)))
-  @test a[Block(2, 2)[(2:3) × (2:3), (2:3) × (2:3)]] ==
-    a[Block(2, 2)][(2:3) × (2:3), (2:3) × (2:3)]
-  @test a[Block(2, 2)[(:) × (2:3), (:) × (2:3)]] == a[Block(2, 2)][(:) × (2:3), (:) × (2:3)]
-  @test a[Block(2, 2)[(1:2) × (2:3), (:) × (2:3)]] ==
-    a[Block(2, 2)][(1:2) × (2:3), (:) × (2:3)]
-
-  # Blockwise slicing, shows up in truncated block sparse matrix factorizations.
-  I1 = BlockIndexVector(Block(1), Base.Slice(Base.OneTo(2)) × [1])
-  I2 = BlockIndexVector(Block(2), Base.Slice(Base.OneTo(3)) × [1, 3])
-  I = [I1, I2]
-  b = a[I, I]
-  @test b[Block(1, 1)] == a[Block(1, 1)[(1:2) × [1], (1:2) × [1]]]
-  @test iszero(b[Block(2, 1)])
-  @test iszero(b[Block(1, 2)])
-  @test b[Block(2, 2)] == a[Block(2, 2)[(1:3) × [1, 3], (1:3) × [1, 3]]]
-
-  # Slicing
-  r = blockrange([2 × 2, 3 × 3])
-  d = Dict(
-    Block(1, 1) => dev(randn(elt, 2, 2) ⊗ randn(elt, 2, 2)),
-    Block(2, 2) => dev(randn(elt, 3, 3) ⊗ randn(elt, 3, 3)),
-  )
-  a = dev(blocksparse(d, (r, r)))
-  i1 = Block(1)[(1:2) × (1:2)]
-  i2 = Block(2)[(2:3) × (2:3)]
-  I = mortar([i1, i2])
-  b = @view a[I, I]
-  b′ = copy(b)
-  @test b[Block(2, 2)] == b′[Block(2, 2)] == a[Block(2, 2)[(2:3) × (2:3), (2:3) × (2:3)]]
-  @test_broken b[Block(1, 2)]
-
-  # Slicing
-  r = blockrange([2 × 2, 3 × 3])
-  d = Dict(
-    Block(1, 1) => dev(randn(elt, 2, 2) ⊗ randn(elt, 2, 2)),
-    Block(2, 2) => dev(randn(elt, 3, 3) ⊗ randn(elt, 3, 3)),
-  )
-  a = dev(blocksparse(d, (r, r)))
-  i1 = Block(1)[(1:2) × (1:2)]
-  i2 = Block(2)[(2:3) × (2:3)]
-  I = [i1, i2]
-  b = @view a[I, I]
-  b′ = copy(b)
-  @test b[Block(2, 2)] == b′[Block(2, 2)] == a[Block(2, 2)[(2:3) × (2:3), (2:3) × (2:3)]]
-  @test_broken b[Block(1, 2)]
-
-  # Matrix multiplication
-  b = a * a
-  @test typeof(b) === typeof(a)
-  @test Array(b) ≈ Array(a) * Array(a)
-
-  # Addition (mapping, broadcasting)
-  b = a + a
-  @test typeof(b) === typeof(a)
-  @test Array(b) ≈ Array(a) + Array(a)
-
-  # Scaling (mapping, broadcasting)
-  b = 3a
-  @test typeof(b) === typeof(a)
-  @test Array(b) ≈ 3Array(a)
-
-  # Dividing (mapping, broadcasting)
-  b = a / 3
-  @test typeof(b) === typeof(a)
-  @test Array(b) ≈ Array(a) / 3
-
-  # Norm
-  @test norm(a) ≈ norm(Array(a))
-
-  if arrayt === Array
-    @test Array(inv(a)) ≈ inv(Array(a))
-  else
-    # Broken on GPU.
-    @test_broken inv(a)
-  end
-
-  if arrayt === Array
-    u, s, v = svd_compact(a)
-    @test Array(u * s * v) ≈ Array(a)
-  else
-    # Broken on GPU.
-    @test_broken svd_compact(a)
-  end
-
-  b = a[Block.(1:2), Block(2)]
-  @test b[Block(1)] == a[Block(1, 2)]
-  @test b[Block(2)] == a[Block(2, 2)]
-
-  # Broken operations
-  @test_broken exp(a)
-end
-
-@testset "BlockSparseArraysExt, EyeKronecker blocks (arraytype=$arrayt, eltype=$elt)" for arrayt in
-                                                                                          arrayts,
-  elt in elts
-
-  dev = adapt(arrayt)
-  r = @constinferred blockrange([2 × 2, 3 × 3])
-  d = Dict(
-    Block(1, 1) => Eye{elt}(2, 2) ⊗ dev(randn(elt, 2, 2)),
-    Block(2, 2) => Eye{elt}(3, 3) ⊗ dev(randn(elt, 3, 3)),
-  )
-  a = @constinferred dev(blocksparse(d, (r, r)))
-  @test sprint(show, a) == sprint(show, Array(a))
-  @test sprint(show, MIME("text/plain"), a) isa String
-  @test @constinferred(blocktype(a)) === valtype(d)
-  @test a isa BlockSparseMatrix{elt,valtype(d)}
-  @test @constinferred(a[Block(1, 1)]) == dev(d[Block(1, 1)])
-  @test @constinferred(a[Block(1, 1)]) isa valtype(d)
-  @test @constinferred(a[Block(2, 2)]) == dev(d[Block(2, 2)])
-  @test @constinferred(a[Block(2, 2)]) isa valtype(d)
-  @test @constinferred(iszero(a[Block(2, 1)]))
-  @test a[Block(2, 1)] == dev(Eye(3, 2) ⊗ zeros(elt, 3, 2))
-  @test a[Block(2, 1)] isa valtype(d)
-  @test iszero(a[Block(1, 2)])
-  @test a[Block(1, 2)] == dev(Eye(2, 3) ⊗ zeros(elt, 2, 3))
-  @test a[Block(1, 2)] isa valtype(d)
-
-  # Slicing
-  r = blockrange([2 × 2, 3 × 3])
-  d = Dict(
-    Block(1, 1) => dev(Eye{elt}(2, 2) ⊗ randn(elt, 2, 2)),
-    Block(2, 2) => dev(Eye{elt}(3, 3) ⊗ randn(elt, 3, 3)),
-  )
-  a = dev(blocksparse(d, (r, r)))
-  @test a[Block(2, 2)[(2:3) × (2:3), (2:3) × (2:3)]] ==
-    a[Block(2, 2)][(2:3) × (2:3), (2:3) × (2:3)]
-  @test a[Block(2, 2)[(:) × (2:3), (:) × (2:3)]] == a[Block(2, 2)][(:) × (2:3), (:) × (2:3)]
-  @test a[Block(2, 2)[(1:2) × (2:3), (:) × (2:3)]] ==
-    a[Block(2, 2)][(1:2) × (2:3), (:) × (2:3)]
-
-  # Blockwise slicing, shows up in truncated block sparse matrix factorizations.
-  I1 = BlockIndexVector(Block(1), Base.Slice(Base.OneTo(2)) × [1])
-  I2 = BlockIndexVector(Block(2), Base.Slice(Base.OneTo(3)) × [1, 3])
-  I = [I1, I2]
-  b = a[I, I]
-  @test b[Block(1, 1)] == a[Block(1, 1)[(1:2) × [1], (1:2) × [1]]]
-  @test arg1(b[Block(1, 1)]) isa Eye
-  @test iszero(b[Block(2, 1)])
-  @test arg1(b[Block(2, 1)]) isa Eye
-  @test iszero(b[Block(1, 2)])
-  @test arg1(b[Block(1, 2)]) isa Eye
-  @test b[Block(2, 2)] == a[Block(2, 2)[(1:3) × [1, 3], (1:3) × [1, 3]]]
-  @test arg1(b[Block(2, 2)]) isa Eye
-
-  # Slicing
-  r = blockrange([2 × 2, 3 × 3])
-  d = Dict(
-    Block(1, 1) => dev(Eye{elt}(2, 2) ⊗ randn(elt, 2, 2)),
-    Block(2, 2) => dev(Eye{elt}(3, 3) ⊗ randn(elt, 3, 3)),
-  )
-  a = dev(blocksparse(d, (r, r)))
-  i1 = Block(1)[(1:2) × (1:2)]
-  i2 = Block(2)[(2:3) × (2:3)]
-  I = mortar([i1, i2])
-  b = @view a[I, I]
-  @test b[Block(2, 2)] == a[Block(2, 2)[(2:3) × (2:3), (2:3) × (2:3)]]
-  @test_broken copy(b)
-  @test_broken b[Block(1, 2)]
-
-  # Slicing
-  r = blockrange([2 × 2, 3 × 3])
-  d = Dict(
-    Block(1, 1) => dev(Eye{elt}(2, 2) ⊗ randn(elt, 2, 2)),
-    Block(2, 2) => dev(Eye{elt}(3, 3) ⊗ randn(elt, 3, 3)),
-  )
-  a = dev(blocksparse(d, (r, r)))
-  i1 = Block(1)[(1:2) × (1:2)]
-  i2 = Block(2)[(2:3) × (2:3)]
-  I = [i1, i2]
-  b = @view a[I, I]
-  @test b[Block(2, 2)] == a[Block(2, 2)[(2:3) × (2:3), (2:3) × (2:3)]]
-  @test_broken copy(b)
-  @test_broken b[Block(1, 2)]
-
-  b = @constinferred a * a
-  @test typeof(b) === typeof(a)
-  @test Array(b) ≈ Array(a) * Array(a)
-
-  # Type inference is broken for this operation.
-  # b = @constinferred a + a
-  b = a + a
-  @test typeof(b) === typeof(a)
-  @test Array(b) ≈ Array(a) + Array(a)
-
-  # Type inference is broken for this operation.
-  # b = @constinferred 3a
-  b = 3a
-  @test typeof(b) === typeof(a)
-  @test Array(b) ≈ 3Array(a)
-
-  # Type inference is broken for this operation.
-  # b = @constinferred a / 3
-  b = a / 3
-  @test typeof(b) === typeof(a)
-  @test Array(b) ≈ Array(a) / 3
-
-  @test @constinferred(norm(a)) ≈ norm(Array(a))
-
-  if arrayt === Array
-    b = @constinferred exp(a)
-    @test Array(b) ≈ exp(Array(a))
-  else
-    @test_broken exp(a)
-  end
-
-  ## if VERSION < v"1.11-" && elt <: Complex
-  ##   # Broken because of type stability issue in Julia v1.10.
-  ##   @test_broken svd_compact(a)
-  if arrayt === Array
-    u, s, v = svd_compact(a)
-    @test u * s * v ≈ a
-    @test blocktype(u) >: blocktype(u)
-    @test eltype(u) === eltype(a)
-    @test blocktype(v) >: blocktype(a)
-    @test eltype(v) === eltype(a)
-    @test eltype(s) === real(eltype(a))
-  else
-    @test_broken svd_compact(a)
-  end
-
-  if arrayt === Array
-    @test Array(inv(a)) ≈ inv(Array(a))
-  else
-    # Broken on GPU.
-    @test_broken inv(a)
-  end
-
-  # Broken operations
-  b = a[Block.(1:2), Block(2)]
-  @test b[Block(1)] == a[Block(1, 2)]
-  @test b[Block(2)] == a[Block(2, 2)]
-
-  # svd_trunc
-  dev = adapt(arrayt)
-  r = @constinferred blockrange([2 × 2, 3 × 3])
-  rng = StableRNG(1234)
-  d = Dict(
-    Block(1, 1) => Eye{elt}(2, 2) ⊗ randn(rng, elt, 2, 2),
-    Block(2, 2) => Eye{elt}(3, 3) ⊗ randn(rng, elt, 3, 3),
-  )
-  a = @constinferred dev(blocksparse(d, (r, r)))
-  if arrayt === Array
-    u, s, v = svd_trunc(a; trunc=(; maxrank=6))
-    u′, s′, v′ = svd_trunc(Matrix(a); trunc=(; maxrank=5))
-    @test Matrix(u * s * v) ≈ u′ * s′ * v′
-  else
-    @test_broken svd_trunc(a; trunc=(; maxrank=6))
-  end
-
-  @testset "Block deficient" begin
-    da = Dict(Block(1, 1) => Eye{elt}(2, 2) ⊗ dev(randn(elt, 2, 2)))
-    a = @constinferred dev(blocksparse(da, (r, r)))
-
-    db = Dict(Block(2, 2) => Eye{elt}(3, 3) ⊗ dev(randn(elt, 3, 3)))
-    b = @constinferred dev(blocksparse(db, (r, r)))
-
-    @test Array(a + b) ≈ Array(a) + Array(b)
-    @test Array(2a) ≈ 2Array(a)
-  end
-end
diff --git a/test/test_fillarrays.jl b/test/test_fillarrays.jl
index 04ef6ad..43877df 100644
--- a/test/test_fillarrays.jl
+++ b/test/test_fillarrays.jl
@@ -6,7 +6,7 @@ using JLArrays: JLArray, jl
 using KroneckerArrays: KroneckerArrays, KroneckerArray, ⊗, ×, arg1, arg2, cartesianrange
 using LinearAlgebra: det, norm, pinv
 using StableRNGs: StableRNG
-using Test: @test, @test_throws, @testset
+using Test: @test, @test_broken, @test_throws, @testset
 using TestExtras: @constinferred
 
 @testset "FillArrays.Eye, DiagonalArrays.Delta" begin
@@ -21,21 +21,24 @@ using TestExtras: @constinferred
   @test a + a == Eye(2) ⊗ (2 * arg2(a))
   @test 2a == Eye(2) ⊗ (2 * arg2(a))
   @test a * a == Eye(2) ⊗ (arg2(a) * arg2(a))
-  @test arg1(a[(:) × (:), (:) × (:)]) ≡ Eye(2)
-  @test arg1(view(a, (:) × (:), (:) × (:))) ≡ Eye(2)
-  @test arg1(a[Base.Slice(Base.OneTo(2)) × (:), (:) × (:)]) ≡ Eye(2)
-  @test arg1(view(a, Base.Slice(Base.OneTo(2)) × (:), (:) × (:))) ≡ Eye(2)
-  @test arg1(a[(:) × (:), Base.Slice(Base.OneTo(2)) × (:)]) ≡ Eye(2)
-  @test arg1(view(a, (:) × (:), Base.Slice(Base.OneTo(2)) × (:))) ≡ Eye(2)
-  @test arg1(a[Base.Slice(Base.OneTo(2)) × (:), Base.Slice(Base.OneTo(2)) × (:)]) ≡ Eye(2)
-  @test arg1(view(a, Base.Slice(Base.OneTo(2)) × (:), Base.Slice(Base.OneTo(2)) × (:))) ≡
+  @test_broken arg1(a[(:) × (:), (:) × (:)]) ≡ Eye(2)
+  @test_broken arg1(view(a, (:) × (:), (:) × (:))) ≡ Eye(2)
+  @test_broken arg1(a[Base.Slice(Base.OneTo(2)) × (:), (:) × (:)]) ≡ Eye(2)
+  @test_broken arg1(view(a, Base.Slice(Base.OneTo(2)) × (:), (:) × (:))) ≡ Eye(2)
+  @test_broken arg1(a[(:) × (:), Base.Slice(Base.OneTo(2)) × (:)]) ≡ Eye(2)
+  @test_broken arg1(view(a, (:) × (:), Base.Slice(Base.OneTo(2)) × (:))) ≡ Eye(2)
+  @test_broken arg1(a[Base.Slice(Base.OneTo(2)) × (:), Base.Slice(Base.OneTo(2)) × (:)]) ≡
     Eye(2)
+  @test_broken arg1(
+    view(a, Base.Slice(Base.OneTo(2)) × (:), Base.Slice(Base.OneTo(2)) × (:))
+  ) ≡ Eye(2)
   @test arg1(adapt(JLArray, a)) ≡ Eye(2)
   @test arg2(adapt(JLArray, a)) == jl(arg2(a))
   @test arg2(adapt(JLArray, a)) isa JLArray
-  @test arg1(similar(a, (cartesianrange(3 × 2), cartesianrange(3 × 2)))) ≡ Eye(3)
-  @test arg1(similar(typeof(a), (cartesianrange(3 × 2), cartesianrange(3 × 2)))) ≡ Eye(3)
-  @test arg1(similar(a, Float32, (cartesianrange(3 × 2), cartesianrange(3 × 2)))) ≡
+  @test_broken arg1(similar(a, (cartesianrange(3 × 2), cartesianrange(3 × 2)))) ≡ Eye(3)
+  @test_broken arg1(similar(typeof(a), (cartesianrange(3 × 2), cartesianrange(3 × 2)))) ≡
+    Eye(3)
+  @test_broken arg1(similar(a, Float32, (cartesianrange(3 × 2), cartesianrange(3 × 2)))) ≡
     Eye{Float32}(3)
   @test arg1(copy(a)) ≡ Eye(2)
   @test arg2(copy(a)) == arg2(a)
@@ -53,21 +56,24 @@ using TestExtras: @constinferred
   @test a + a == (2 * arg1(a)) ⊗ Eye(2)
   @test 2a == (2 * arg1(a)) ⊗ Eye(2)
   @test a * a == (arg1(a) * arg1(a)) ⊗ Eye(2)
-  @test arg2(a[(:) × (:), (:) × (:)]) ≡ Eye(2)
-  @test arg2(view(a, (:) × (:), (:) × (:))) ≡ Eye(2)
-  @test arg2(a[Base.Slice(Base.OneTo(2)) × (:), (:) × (:)]) ≡ Eye(2)
-  @test arg2(view(a, Base.Slice(Base.OneTo(2)) × (:), (:) × (:))) ≡ Eye(2)
-  @test arg2(a[(:) × (:), Base.Slice(Base.OneTo(2)) × (:)]) ≡ Eye(2)
-  @test arg2(view(a, (:) × (:), Base.Slice(Base.OneTo(2)) × (:))) ≡ Eye(2)
-  @test arg2(a[Base.Slice(Base.OneTo(2)) × (:), Base.Slice(Base.OneTo(2)) × (:)]) ≡ Eye(2)
-  @test arg2(view(a, Base.Slice(Base.OneTo(2)) × (:), Base.Slice(Base.OneTo(2)) × (:))) ≡
+  @test_broken arg2(a[(:) × (:), (:) × (:)]) ≡ Eye(2)
+  @test_broken arg2(view(a, (:) × (:), (:) × (:))) ≡ Eye(2)
+  @test_broken arg2(a[Base.Slice(Base.OneTo(2)) × (:), (:) × (:)]) ≡ Eye(2)
+  @test_broken arg2(view(a, Base.Slice(Base.OneTo(2)) × (:), (:) × (:))) ≡ Eye(2)
+  @test_broken arg2(a[(:) × (:), Base.Slice(Base.OneTo(2)) × (:)]) ≡ Eye(2)
+  @test_broken arg2(view(a, (:) × (:), Base.Slice(Base.OneTo(2)) × (:))) ≡ Eye(2)
+  @test_broken arg2(a[Base.Slice(Base.OneTo(2)) × (:), Base.Slice(Base.OneTo(2)) × (:)]) ≡
     Eye(2)
+  @test_broken arg2(
+    view(a, Base.Slice(Base.OneTo(2)) × (:), Base.Slice(Base.OneTo(2)) × (:))
+  ) ≡ Eye(2)
   @test arg2(adapt(JLArray, a)) ≡ Eye(2)
   @test arg1(adapt(JLArray, a)) == jl(arg1(a))
   @test arg1(adapt(JLArray, a)) isa JLArray
-  @test arg2(similar(a, (cartesianrange(2 × 3), cartesianrange(2 × 3)))) ≡ Eye(3)
-  @test arg2(similar(typeof(a), (cartesianrange(2 × 3), cartesianrange(2 × 3)))) ≡ Eye(3)
-  @test arg2(similar(a, Float32, (cartesianrange(2 × 3), cartesianrange(2 × 3)))) ≡
+  @test_broken arg2(similar(a, (cartesianrange(2 × 3), cartesianrange(2 × 3)))) ≡ Eye(3)
+  @test_broken arg2(similar(typeof(a), (cartesianrange(2 × 3), cartesianrange(2 × 3)))) ≡
+    Eye(3)
+  @test_broken arg2(similar(a, Float32, (cartesianrange(2 × 3), cartesianrange(2 × 3)))) ≡
     Eye{Float32}(3)
   @test arg2(copy(a)) ≡ Eye(2)
   @test arg2(copy(a)) == arg2(a)
@@ -85,20 +91,23 @@ using TestExtras: @constinferred
   @test a + a == δ(2, 2) ⊗ (2 * arg2(a))
   @test 2a == δ(2, 2) ⊗ (2 * arg2(a))
   @test a * a == δ(2, 2) ⊗ (arg2(a) * arg2(a))
-  @test arg1(a[(:) × (:), (:) × (:)]) ≡ δ(2, 2)
-  @test arg1(a[Base.Slice(Base.OneTo(2)) × (:), (:) × (:)]) ≡ δ(2, 2)
-  @test arg1(view(a, Base.Slice(Base.OneTo(2)) × (:), (:) × (:))) ≡ δ(2, 2)
-  @test arg1(a[(:) × (:), Base.Slice(Base.OneTo(2)) × (:)]) ≡ δ(2, 2)
-  @test arg1(view(a, (:) × (:), Base.Slice(Base.OneTo(2)) × (:))) ≡ δ(2, 2)
-  @test arg1(a[Base.Slice(Base.OneTo(2)) × (:), Base.Slice(Base.OneTo(2)) × (:)]) ≡ δ(2, 2)
-  @test arg1(view(a, Base.Slice(Base.OneTo(2)) × (:), Base.Slice(Base.OneTo(2)) × (:))) ≡
+  @test_broken arg1(a[(:) × (:), (:) × (:)]) ≡ δ(2, 2)
+  @test_broken arg1(a[Base.Slice(Base.OneTo(2)) × (:), (:) × (:)]) ≡ δ(2, 2)
+  @test_broken arg1(view(a, Base.Slice(Base.OneTo(2)) × (:), (:) × (:))) ≡ δ(2, 2)
+  @test_broken arg1(a[(:) × (:), Base.Slice(Base.OneTo(2)) × (:)]) ≡ δ(2, 2)
+  @test_broken arg1(view(a, (:) × (:), Base.Slice(Base.OneTo(2)) × (:))) ≡ δ(2, 2)
+  @test_broken arg1(a[Base.Slice(Base.OneTo(2)) × (:), Base.Slice(Base.OneTo(2)) × (:)]) ≡
     δ(2, 2)
+  @test_broken arg1(
+    view(a, Base.Slice(Base.OneTo(2)) × (:), Base.Slice(Base.OneTo(2)) × (:))
+  ) ≡ δ(2, 2)
   @test arg1(adapt(JLArray, a)) ≡ δ(2, 2)
   @test arg2(adapt(JLArray, a)) == jl(arg2(a))
   @test arg2(adapt(JLArray, a)) isa JLArray
-  @test arg1(similar(a, (cartesianrange(3 × 2), cartesianrange(3 × 2)))) ≡ δ(3, 3)
-  @test arg1(similar(typeof(a), (cartesianrange(3 × 2), cartesianrange(3 × 2)))) ≡ δ(3, 3)
-  @test arg1(similar(a, Float32, (cartesianrange(3 × 2), cartesianrange(3 × 2)))) ≡
+  @test_broken arg1(similar(a, (cartesianrange(3 × 2), cartesianrange(3 × 2)))) ≡ δ(3, 3)
+  @test_broken arg1(similar(typeof(a), (cartesianrange(3 × 2), cartesianrange(3 × 2)))) ≡
+    δ(3, 3)
+  @test_broken arg1(similar(a, Float32, (cartesianrange(3 × 2), cartesianrange(3 × 2)))) ≡
     δ(Float32, 3, 3)
   @test arg1(copy(a)) ≡ δ(2, 2)
   @test arg2(copy(a)) == arg2(a)
@@ -116,21 +125,24 @@ using TestExtras: @constinferred
   @test a + a == (2 * arg1(a)) ⊗ δ(2, 2)
   @test 2a == (2 * arg1(a)) ⊗ δ(2, 2)
   @test a * a == (arg1(a) * arg1(a)) ⊗ δ(2, 2)
-  @test arg2(a[(:) × (:), (:) × (:)]) ≡ δ(2, 2)
-  @test arg2(view(a, (:) × (:), (:) × (:))) ≡ δ(2, 2)
-  @test arg2(a[Base.Slice(Base.OneTo(2)) × (:), (:) × (:)]) ≡ δ(2, 2)
-  @test arg2(view(a, Base.Slice(Base.OneTo(2)) × (:), (:) × (:))) ≡ δ(2, 2)
-  @test arg2(a[(:) × (:), Base.Slice(Base.OneTo(2)) × (:)]) ≡ δ(2, 2)
-  @test arg2(view(a, (:) × (:), Base.Slice(Base.OneTo(2)) × (:))) ≡ δ(2, 2)
-  @test arg2(a[Base.Slice(Base.OneTo(2)) × (:), Base.Slice(Base.OneTo(2)) × (:)]) ≡ δ(2, 2)
-  @test arg2(view(a, Base.Slice(Base.OneTo(2)) × (:), Base.Slice(Base.OneTo(2)) × (:))) ≡
+  @test_broken arg2(a[(:) × (:), (:) × (:)]) ≡ δ(2, 2)
+  @test_broken arg2(view(a, (:) × (:), (:) × (:))) ≡ δ(2, 2)
+  @test_broken arg2(a[Base.Slice(Base.OneTo(2)) × (:), (:) × (:)]) ≡ δ(2, 2)
+  @test_broken arg2(view(a, Base.Slice(Base.OneTo(2)) × (:), (:) × (:))) ≡ δ(2, 2)
+  @test_broken arg2(a[(:) × (:), Base.Slice(Base.OneTo(2)) × (:)]) ≡ δ(2, 2)
+  @test_broken arg2(view(a, (:) × (:), Base.Slice(Base.OneTo(2)) × (:))) ≡ δ(2, 2)
+  @test_broken arg2(a[Base.Slice(Base.OneTo(2)) × (:), Base.Slice(Base.OneTo(2)) × (:)]) ≡
     δ(2, 2)
+  @test_broken arg2(
+    view(a, Base.Slice(Base.OneTo(2)) × (:), Base.Slice(Base.OneTo(2)) × (:))
+  ) ≡ δ(2, 2)
   @test arg2(adapt(JLArray, a)) ≡ δ(2, 2)
   @test arg1(adapt(JLArray, a)) == jl(arg1(a))
   @test arg1(adapt(JLArray, a)) isa JLArray
-  @test arg2(similar(a, (cartesianrange(2 × 3), cartesianrange(2 × 3)))) ≡ δ(3, 3)
-  @test arg2(similar(typeof(a), (cartesianrange(2 × 3), cartesianrange(2 × 3)))) ≡ δ(3, 3)
-  @test arg2(similar(a, Float32, (cartesianrange(2 × 3), cartesianrange(2 × 3)))) ≡
+  @test_broken arg2(similar(a, (cartesianrange(2 × 3), cartesianrange(2 × 3)))) ≡ δ(3, 3)
+  @test_broken arg2(similar(typeof(a), (cartesianrange(2 × 3), cartesianrange(2 × 3)))) ≡
+    δ(3, 3)
+  @test_broken arg2(similar(a, Float32, (cartesianrange(2 × 3), cartesianrange(2 × 3)))) ≡
     δ(Float32, (3, 3))
   @test arg2(copy(a)) ≡ δ(2, 2)
   @test arg2(copy(a)) == arg2(a)
@@ -146,87 +158,115 @@ using TestExtras: @constinferred
   # Views
   a = @constinferred(Eye(2) ⊗ randn(3, 3))
   b = @constinferred(view(a, (:) × (2:3), (:) × (2:3)))
-  @test arg1(b) === Eye(2)
-  @test arg2(b) === view(arg2(a), 2:3, 2:3)
+  @test_broken arg1(b) ≡ Eye(2)
+  @test arg2(b) ≡ view(arg2(a), 2:3, 2:3)
   @test arg2(b) == arg2(a)[2:3, 2:3]
 
   a = randn(3, 3) ⊗ Eye(2)
   @test size(a) == (6, 6)
-  @test a + a == (2a.a) ⊗ Eye(2)
-  @test 2a == (2a.a) ⊗ Eye(2)
-  @test a * a == (a.a * a.a) ⊗ Eye(2)
+  @test a + a == (2arg1(a)) ⊗ Eye(2)
+  @test 2a == (2arg1(a)) ⊗ Eye(2)
+  @test a * a == (arg1(a) * arg1(a)) ⊗ Eye(2)
 
   # Views
   a = @constinferred(randn(3, 3) ⊗ Eye(2))
   b = @constinferred(view(a, (2:3) × (:), (2:3) × (:)))
-  @test arg1(b) === view(arg1(a), 2:3, 2:3)
+  @test arg1(b) ≡ view(arg1(a), 2:3, 2:3)
   @test arg1(b) == arg1(a)[2:3, 2:3]
-  @test arg2(b) === Eye(2)
+  @test_broken arg2(b) ≡ Eye(2)
 
   # similar
   a = Eye(2) ⊗ randn(3, 3)
-  for a′ in (
-    similar(a),
-    similar(a, eltype(a)),
-    similar(a, axes(a)),
-    similar(a, eltype(a), axes(a)),
-    similar(typeof(a), axes(a)),
-  )
-    @test size(a′) == (6, 6)
-    @test a′ isa KroneckerArray{eltype(a),ndims(a),typeof(a.a),typeof(a.b)}
-    @test a′.a === a.a
-  end
+  a′ = similar(a)
+  @test size(a′) == (6, 6)
+  @test a′ isa KroneckerArray{eltype(a),ndims(a)}
+  @test arg1(a′) ≡ arg1(a)
 
   a = Eye(2) ⊗ randn(3, 3)
-  for args in ((Float32,), (Float32, axes(a)))
-    a′ = similar(a, args...)
-    @test size(a′) == (6, 6)
-    @test a′ isa KroneckerArray{Float32,ndims(a)}
-    @test a′.a === Eye{Float32}(2)
-  end
+  a′ = similar(a, eltype(a))
+  @test size(a′) == (6, 6)
+  @test a′ isa KroneckerArray{eltype(a),ndims(a)}
+  @test_broken arg1(a′) ≡ arg1(a)
+
+  a = Eye(2) ⊗ randn(3, 3)
+  a′ = similar(a, axes(a))
+  @test size(a′) == (6, 6)
+  @test a′ isa KroneckerArray{eltype(a),ndims(a)}
+  @test_broken arg1(a′) ≡ arg1(a)
+
+  a = Eye(2) ⊗ randn(3, 3)
+  a′ = similar(a, eltype(a), axes(a))
+  @test size(a′) == (6, 6)
+  @test a′ isa KroneckerArray{eltype(a),ndims(a)}
+  @test_broken arg1(a′) ≡ arg1(a)
+
+  @test_broken similar(typeof(a), axes(a))
+
+  a = Eye(2) ⊗ randn(3, 3)
+  a′ = similar(a, Float32)
+  @test size(a′) == (6, 6)
+  @test a′ isa KroneckerArray{Float32,ndims(a)}
+  @test_broken arg1(a′) ≡ Eye{Float32}(2)
+
+  a = Eye(2) ⊗ randn(3, 3)
+  a′ = similar(a, Float32, axes(a))
+  @test size(a′) == (6, 6)
+  @test a′ isa KroneckerArray{Float32,ndims(a)}
+  @test_broken arg1(a′) ≡ Eye{Float32}(2)
 
   a = randn(3, 3) ⊗ Eye(2)
-  for a′ in (
-    similar(a),
-    similar(a, eltype(a)),
-    similar(a, axes(a)),
-    similar(a, eltype(a), axes(a)),
-    similar(typeof(a), axes(a)),
-  )
-    @test size(a′) == (6, 6)
-    @test a′ isa KroneckerArray{eltype(a),ndims(a),typeof(a.a),typeof(a.b)}
-    @test a′.b === a.b
-  end
+  a′ = similar(a)
+  @test size(a′) == (6, 6)
+  @test a′ isa KroneckerArray{eltype(a),ndims(a)}
+  @test arg2(a′) ≡ arg2(a)
 
   a = randn(3, 3) ⊗ Eye(2)
-  for args in ((Float32,), (Float32, axes(a)))
-    a′ = similar(a, args...)
-    @test size(a′) == (6, 6)
-    @test a′ isa KroneckerArray{Float32,ndims(a)}
-    @test a′.b === Eye{Float32}(2)
-  end
+  a′ = similar(a, eltype(a))
+  @test size(a′) == (6, 6)
+  @test a′ isa KroneckerArray{eltype(a),ndims(a)}
+  @test_broken arg2(a′) ≡ arg2(a)
+
+  a = randn(3, 3) ⊗ Eye(2)
+  a′ = similar(a, axes(a))
+  @test size(a′) == (6, 6)
+  @test a′ isa KroneckerArray{eltype(a),ndims(a)}
+  @test_broken arg2(a′) ≡ arg2(a)
+
+  a = randn(3, 3) ⊗ Eye(2)
+  a′ = similar(a, eltype(a), axes(a))
+  @test size(a′) == (6, 6)
+  @test a′ isa KroneckerArray{eltype(a),ndims(a)}
+  @test_broken arg2(a′) ≡ arg2(a)
+
+  @test_broken similar(typeof(a), axes(a))
+
+  a = randn(3, 3) ⊗ Eye(2)
+  a′ = similar(a, Float32)
+  @test size(a′) == (6, 6)
+  @test a′ isa KroneckerArray{Float32,ndims(a)}
+  # This is broken because of:
+  # https://github.com/JuliaArrays/FillArrays.jl/issues/415
+  @test_broken arg2(a′) ≡ Eye{Float32}(2)
+
+  a = randn(3, 3) ⊗ Eye(2)
+  a′ = similar(a, Float32, axes(a))
+  @test size(a′) == (6, 6)
+  @test a′ isa KroneckerArray{Float32,ndims(a)}
 
   a = Eye(3) ⊗ Eye(2)
   for a′ in (
-    similar(a),
-    similar(a, eltype(a)),
-    similar(a, axes(a)),
-    similar(a, eltype(a), axes(a)),
-    similar(typeof(a), axes(a)),
+    similar(a), similar(a, eltype(a)), similar(a, axes(a)), similar(a, eltype(a), axes(a))
   )
     @test size(a′) == (6, 6)
-    @test a′ isa KroneckerArray{eltype(a),ndims(a),typeof(a.a),typeof(a.b)}
-    @test a′.a === a.a
-    @test a′.b === a.b
+    @test a′ isa KroneckerArray{eltype(a),ndims(a)}
   end
+  @test_broken similar(typeof(a), axes(a))
 
   a = Eye(3) ⊗ Eye(2)
   for args in ((Float32,), (Float32, axes(a)))
     a′ = similar(a, args...)
     @test size(a′) == (6, 6)
     @test a′ isa KroneckerArray{Float32,ndims(a)}
-    @test a′.a === Eye{Float32}(3)
-    @test a′.b === Eye{Float32}(2)
   end
 
   # DerivableInterfaces.zero!
@@ -235,7 +275,7 @@ using TestExtras: @constinferred
     @test iszero(a)
   end
   a = Eye(3) ⊗ Eye(2)
-  @test_throws ArgumentError zero!(a)
+  @test_throws ErrorException zero!(a)
 
   # map!(+, ...)
   for a in (Eye(2) ⊗ randn(3, 3), randn(3, 3) ⊗ Eye(2))
@@ -245,7 +285,8 @@ using TestExtras: @constinferred
   end
   a = Eye(3) ⊗ Eye(2)
   a′ = similar(a)
-  @test_throws ErrorException map!(+, a′, a, a)
+  map!(+, a′, a, a)
+  @test a′ ≈ 2a
 
   # map!(-, ...)
   for a in (Eye(2) ⊗ randn(3, 3), randn(3, 3) ⊗ Eye(2))
@@ -255,7 +296,8 @@ using TestExtras: @constinferred
   end
   a = Eye(3) ⊗ Eye(2)
   a′ = similar(a)
-  @test_throws ErrorException map!(-, a′, a, a)
+  map!(-, a′, a, a)
+  @test iszero(a′)
 
   # map!(-, b, a)
   for a in (Eye(2) ⊗ randn(3, 3), randn(3, 3) ⊗ Eye(2))
@@ -265,7 +307,8 @@ using TestExtras: @constinferred
   end
   a = Eye(3) ⊗ Eye(2)
   a′ = similar(a)
-  @test_throws ErrorException map!(-, a′, a)
+  map!(-, a′, a)
+  @test a′ ≈ -a
 
   # Eye ⊗ A
   rng = StableRNG(123)
@@ -274,17 +317,17 @@ using TestExtras: @constinferred
     @eval begin
       fa = $f($a)
       @test collect(fa) ≈ $f(collect($a)) rtol = ∜(eps(real(eltype($a))))
-      @test fa.a isa Eye
+      @test arg1(fa) isa Eye
     end
   end
 
   fa = inv(a)
   @test collect(fa) ≈ inv(collect(a))
-  @test fa.a isa Eye
+  @test arg1(fa) isa Eye
 
   fa = pinv(a)
   @test collect(fa) ≈ pinv(collect(a))
-  @test fa.a isa Eye
+  @test arg1(fa) isa Eye
 
   @test det(a) ≈ det(collect(a))
 
@@ -295,17 +338,17 @@ using TestExtras: @constinferred
     @eval begin
       fa = $f($a)
       @test collect(fa) ≈ $f(collect($a)) rtol = ∜(eps(real(eltype($a))))
-      @test fa.b isa Eye
+      @test arg2(fa) isa Eye
     end
   end
 
   fa = inv(a)
   @test collect(fa) ≈ inv(collect(a))
-  @test fa.b isa Eye
+  @test arg2(fa) isa Eye
 
   fa = pinv(a)
   @test collect(fa) ≈ pinv(collect(a))
-  @test fa.b isa Eye
+  @test arg2(fa) isa Eye
 
   @test det(a) ≈ det(collect(a))
 
@@ -319,13 +362,13 @@ using TestExtras: @constinferred
 
   fa = inv(a)
   @test fa == a
-  @test fa.a isa Eye
-  @test fa.b isa Eye
+  @test arg1(fa) isa Eye
+  @test arg2(fa) isa Eye
 
   fa = pinv(a)
   @test fa == a
-  @test fa.a isa Eye
-  @test fa.b isa Eye
+  @test arg1(fa) isa Eye
+  @test arg2(fa) isa Eye
 
   @test det(a) ≈ det(collect(a)) ≈ 1
 
diff --git a/test/test_fillarrays_matrixalgebrakit.jl b/test/test_fillarrays_matrixalgebrakit.jl
index d785bd6..8b0d566 100644
--- a/test/test_fillarrays_matrixalgebrakit.jl
+++ b/test/test_fillarrays_matrixalgebrakit.jl
@@ -1,4 +1,5 @@
-using FillArrays: Eye, Ones
+using FillArrays: Ones
+using DiagonalArrays: δ, DeltaMatrix
 using KroneckerArrays: ⊗, arguments
 using LinearAlgebra: Hermitian, I, diag, hermitianpart, norm
 using MatrixAlgebraKit:
@@ -22,93 +23,94 @@ using MatrixAlgebraKit:
   svd_full,
   svd_trunc,
   svd_vals
-using Test: @test, @test_throws, @testset
+using Test: @test, @test_broken, @test_throws, @testset
 using TestExtras: @constinferred
 
 herm(a) = parent(hermitianpart(a))
 
-@testset "MatrixAlgebraKit + Eye" begin
+@testset "MatrixAlgebraKit + DeltaMatrix" begin
   for elt in (Float32, ComplexF32)
-    a = Eye{elt}(3, 3) ⊗ randn(elt, 3, 3)
+    a = δ(elt, 3, 3) ⊗ randn(elt, 3, 3)
     d, v = @constinferred eig_full(a)
     @test a * v ≈ v * d
-    @test arguments(d, 1) isa Eye{complex(elt)}
-    @test arguments(v, 1) isa Eye{complex(elt)}
+    @test arguments(d, 1) isa DeltaMatrix{complex(elt)}
+    @test arguments(v, 1) isa DeltaMatrix{complex(elt)}
 
-    a = parent(hermitianpart(randn(elt, 3, 3))) ⊗ Eye{elt}(3, 3)
+    a = parent(hermitianpart(randn(elt, 3, 3))) ⊗ δ(elt, 3, 3)
     d, v = @constinferred eig_full(a)
     @test a * v ≈ v * d
-    @test arguments(d, 2) isa Eye{complex(elt)}
-    @test arguments(v, 2) isa Eye{complex(elt)}
+    @test arguments(d, 2) isa DeltaMatrix{complex(elt)}
+    @test arguments(v, 2) isa DeltaMatrix{complex(elt)}
 
-    a = Eye{elt}(3, 3) ⊗ Eye{elt}(3, 3)
+    a = δ(elt, 3, 3) ⊗ δ(elt, 3, 3)
     d, v = @constinferred eig_full(a)
     @test a * v ≈ v * d
-    @test arguments(d, 1) isa Eye{complex(elt)}
-    @test arguments(d, 2) isa Eye{complex(elt)}
-    @test arguments(v, 1) isa Eye{complex(elt)}
-    @test arguments(v, 2) isa Eye{complex(elt)}
+    @test arguments(d, 1) isa DeltaMatrix{complex(elt)}
+    @test arguments(d, 2) isa DeltaMatrix{complex(elt)}
+    @test arguments(v, 1) isa DeltaMatrix{complex(elt)}
+    @test arguments(v, 2) isa DeltaMatrix{complex(elt)}
   end
 
   for elt in (Float32, ComplexF32)
-    a = Eye{elt}(3, 3) ⊗ parent(hermitianpart(randn(elt, 3, 3)))
+    a = δ(elt, 3, 3) ⊗ parent(hermitianpart(randn(elt, 3, 3)))
     d, v = @constinferred eigh_full($a)
     @test a * v ≈ v * d
-    @test arguments(d, 1) isa Eye{real(elt)}
-    @test arguments(v, 1) isa Eye{elt}
+    @test arguments(d, 1) isa DeltaMatrix{real(elt)}
+    @test arguments(v, 1) isa DeltaMatrix{elt}
 
-    a = parent(hermitianpart(randn(elt, 3, 3))) ⊗ Eye{elt}(3, 3)
+    a = parent(hermitianpart(randn(elt, 3, 3))) ⊗ δ(elt, 3, 3)
     d, v = @constinferred eigh_full($a)
     @test a * v ≈ v * d
-    @test arguments(d, 2) isa Eye{real(elt)}
-    @test arguments(v, 2) isa Eye{elt}
+    @test arguments(d, 2) isa DeltaMatrix{real(elt)}
+    @test arguments(v, 2) isa DeltaMatrix{elt}
 
-    a = Eye{elt}(3, 3) ⊗ Eye{elt}(3, 3)
+    a = δ(elt, 3, 3) ⊗ δ(elt, 3, 3)
     d, v = @constinferred eigh_full($a)
     @test a * v ≈ v * d
-    @test arguments(d, 1) isa Eye{real(elt)}
-    @test arguments(d, 2) isa Eye{real(elt)}
-    @test arguments(v, 1) isa Eye{elt}
-    @test arguments(v, 2) isa Eye{elt}
+    @test arguments(d, 1) isa DeltaMatrix{real(elt)}
+    @test arguments(d, 2) isa DeltaMatrix{real(elt)}
+    @test arguments(v, 1) isa DeltaMatrix{elt}
+    @test arguments(v, 2) isa DeltaMatrix{elt}
   end
 
-  for f in (eig_trunc, eigh_trunc)
-    a = Eye(3) ⊗ parent(hermitianpart(randn(3, 3)))
-    d, v = f(a; trunc=(; maxrank=7))
-    @test a * v ≈ v * d
-    @test arguments(d, 1) isa Eye
-    @test arguments(v, 1) isa Eye
-    @test size(d) == (6, 6)
-    @test size(v) == (9, 6)
+  ## TODO: Broken, need to fix truncation.
+  ## for f in (eig_trunc, eigh_trunc)
+  ##   a = δ(3, 3) ⊗ parent(hermitianpart(randn(3, 3)))
+  ##   d, v = f(a; trunc=(; maxrank=7))
+  ##   @test a * v ≈ v * d
+  ##   @test arguments(d, 1) isa DeltaMatrix
+  ##   @test arguments(v, 1) isa DeltaMatrix
+  ##   @test size(d) == (6, 6)
+  ##   @test size(v) == (9, 6)
 
-    a = parent(hermitianpart(randn(3, 3))) ⊗ Eye(3)
-    d, v = f(a; trunc=(; maxrank=7))
-    @test a * v ≈ v * d
-    @test arguments(d, 2) isa Eye
-    @test arguments(v, 2) isa Eye
-    @test size(d) == (6, 6)
-    @test size(v) == (9, 6)
+  ##   a = parent(hermitianpart(randn(3, 3))) ⊗ δ(3, 3)
+  ##   d, v = f(a; trunc=(; maxrank=7))
+  ##   @test a * v ≈ v * d
+  ##   @test arguments(d, 2) isa DeltaMatrix
+  ##   @test arguments(v, 2) isa DeltaMatrix
+  ##   @test size(d) == (6, 6)
+  ##   @test size(v) == (9, 6)
 
-    a = Eye(3) ⊗ Eye(3)
-    @test_throws ArgumentError f(a)
-  end
+  ##   a = δ(3, 3) ⊗ δ(3, 3)
+  ##   @test_throws ArgumentError f(a)
+  ## end
 
   for f in (eig_vals, eigh_vals)
-    a = Eye(3) ⊗ parent(hermitianpart(randn(3, 3)))
+    a = δ(3, 3) ⊗ parent(hermitianpart(randn(3, 3)))
     d = @constinferred f(a)
     d′ = f(Matrix(a))
     @test sort(Vector(d); by=abs) ≈ sort(d′; by=abs)
     @test arguments(d, 1) isa Ones
     @test arguments(d, 2) ≈ f(arguments(a, 2))
 
-    a = parent(hermitianpart(randn(3, 3))) ⊗ Eye(3)
+    a = parent(hermitianpart(randn(3, 3))) ⊗ δ(3, 3)
     d = @constinferred f(a)
     d′ = f(Matrix(a))
     @test sort(Vector(d); by=abs) ≈ sort(d′; by=abs)
     @test arguments(d, 2) isa Ones
     @test arguments(d, 1) ≈ f(arguments(a, 1))
 
-    a = Eye(3) ⊗ Eye(3)
+    a = δ(3, 3) ⊗ δ(3, 3)
     d = @constinferred f(a)
     @test d == Ones(3) ⊗ Ones(3)
     @test arguments(d, 1) isa Ones
@@ -118,109 +120,111 @@ herm(a) = parent(hermitianpart(a))
   for f in (
     left_orth, right_orth, left_polar, right_polar, qr_compact, lq_compact, qr_full, lq_full
   )
-    a = Eye(3, 3) ⊗ randn(3, 3)
+    a = δ(3, 3) ⊗ randn(3, 3)
     x, y = @constinferred f($a)
     @test x * y ≈ a
-    @test arguments(x, 1) isa Eye
-    @test arguments(y, 1) isa Eye
+    @test arguments(x, 1) isa DeltaMatrix
+    @test arguments(y, 1) isa DeltaMatrix
 
-    a = randn(3, 3) ⊗ Eye(3, 3)
+    a = randn(3, 3) ⊗ δ(3, 3)
     x, y = @constinferred f($a)
     @test x * y ≈ a
-    @test arguments(x, 2) isa Eye
-    @test arguments(y, 2) isa Eye
+    @test arguments(x, 2) isa DeltaMatrix
+    @test arguments(y, 2) isa DeltaMatrix
 
-    a = Eye(3, 3) ⊗ Eye(3, 3)
+    a = δ(3, 3) ⊗ δ(3, 3)
     x, y = @constinferred f($a)
     @test x * y ≈ a
-    @test arguments(x, 1) isa Eye
-    @test arguments(y, 1) isa Eye
-    @test arguments(x, 2) isa Eye
-    @test arguments(y, 2) isa Eye
+    @test arguments(x, 1) isa DeltaMatrix
+    @test arguments(y, 1) isa DeltaMatrix
+    @test arguments(x, 2) isa DeltaMatrix
+    @test arguments(y, 2) isa DeltaMatrix
   end
 
   for f in (svd_compact, svd_full)
     for elt in (Float32, ComplexF32)
-      a = Eye{elt}(3, 3) ⊗ randn(elt, 3, 3)
+      a = δ(elt, 3, 3) ⊗ randn(elt, 3, 3)
       u, s, v = @constinferred f($a)
       @test u * s * v ≈ a
       @test eltype(u) === elt
       @test eltype(s) === real(elt)
       @test eltype(v) === elt
-      @test arguments(u, 1) isa Eye{elt}
-      @test arguments(s, 1) isa Eye{real(elt)}
-      @test arguments(v, 1) isa Eye{elt}
+      @test arguments(u, 1) isa DeltaMatrix{elt}
+      @test arguments(s, 1) isa DeltaMatrix{real(elt)}
+      @test arguments(v, 1) isa DeltaMatrix{elt}
 
-      a = randn(elt, 3, 3) ⊗ Eye{elt}(3, 3)
+      a = randn(elt, 3, 3) ⊗ δ(elt, 3, 3)
       u, s, v = @constinferred f($a)
       @test u * s * v ≈ a
       @test eltype(u) === elt
       @test eltype(s) === real(elt)
       @test eltype(v) === elt
-      @test arguments(u, 2) isa Eye{elt}
-      @test arguments(s, 2) isa Eye{real(elt)}
-      @test arguments(v, 2) isa Eye{elt}
+      @test arguments(u, 2) isa DeltaMatrix{elt}
+      @test arguments(s, 2) isa DeltaMatrix{real(elt)}
+      @test arguments(v, 2) isa DeltaMatrix{elt}
 
-      a = Eye{elt}(3, 3) ⊗ Eye{elt}(3, 3)
+      a = δ(elt, 3, 3) ⊗ δ(elt, 3, 3)
       u, s, v = @constinferred f($a)
       @test u * s * v ≈ a
       @test eltype(u) === elt
       @test eltype(s) === real(elt)
       @test eltype(v) === elt
-      @test arguments(u, 1) isa Eye{elt}
-      @test arguments(s, 1) isa Eye{real(elt)}
-      @test arguments(v, 1) isa Eye{elt}
-      @test arguments(u, 2) isa Eye{elt}
-      @test arguments(s, 2) isa Eye{real(elt)}
-      @test arguments(v, 2) isa Eye{elt}
+      @test arguments(u, 1) isa DeltaMatrix{elt}
+      @test arguments(s, 1) isa DeltaMatrix{real(elt)}
+      @test arguments(v, 1) isa DeltaMatrix{elt}
+      @test arguments(u, 2) isa DeltaMatrix{elt}
+      @test arguments(s, 2) isa DeltaMatrix{real(elt)}
+      @test arguments(v, 2) isa DeltaMatrix{elt}
     end
   end
 
-  # svd_trunc
-  for elt in (Float32, ComplexF32)
-    a = Eye{elt}(3, 3) ⊗ randn(elt, 3, 3)
-    # TODO: Type inference is broken for `svd_trunc`,
-    # look into fixing it.
-    # u, s, v = @constinferred svd_trunc(a; trunc=(; maxrank=7))
-    u, s, v = svd_trunc(a; trunc=(; maxrank=7))
-    @test eltype(u) === elt
-    @test eltype(s) === real(elt)
-    @test eltype(v) === elt
-    u′, s′, v′ = svd_trunc(Matrix(a); trunc=(; maxrank=6))
-    @test Matrix(u * s * v) ≈ u′ * s′ * v′
-    @test arguments(u, 1) isa Eye{elt}
-    @test arguments(s, 1) isa Eye{real(elt)}
-    @test arguments(v, 1) isa Eye{elt}
-    @test size(u) == (9, 6)
-    @test size(s) == (6, 6)
-    @test size(v) == (6, 9)
-  end
+  ## TODO: Need to implement truncation.
+  ## # svd_trunc
+  ## for elt in (Float32, ComplexF32)
+  ##   a = δ(elt, 3, 3) ⊗ randn(elt, 3, 3)
+  ##   # TODO: Type inference is broken for `svd_trunc`,
+  ##   # look into fixing it.
+  ##   # u, s, v = @constinferred svd_trunc(a; trunc=(; maxrank=7))
+  ##   u, s, v = svd_trunc(a; trunc=(; maxrank=7))
+  ##   @test eltype(u) === elt
+  ##   @test eltype(s) === real(elt)
+  ##   @test eltype(v) === elt
+  ##   u′, s′, v′ = svd_trunc(Matrix(a); trunc=(; maxrank=6))
+  ##   @test Matrix(u * s * v) ≈ u′ * s′ * v′
+  ##   @test arguments(u, 1) isa DeltaMatrix{elt}
+  ##   @test arguments(s, 1) isa DeltaMatrix{real(elt)}
+  ##   @test arguments(v, 1) isa DeltaMatrix{elt}
+  ##   @test size(u) == (9, 6)
+  ##   @test size(s) == (6, 6)
+  ##   @test size(v) == (6, 9)
+  ## end
 
-  for elt in (Float32, ComplexF32)
-    a = randn(elt, 3, 3) ⊗ Eye{elt}(3, 3)
-    # TODO: Type inference is broken for `svd_trunc`,
-    # look into fixing it.
-    # u, s, v = @constinferred svd_trunc(a; trunc=(; maxrank=7))
-    u, s, v = svd_trunc(a; trunc=(; maxrank=7))
-    @test eltype(u) === elt
-    @test eltype(s) === real(elt)
-    @test eltype(v) === elt
-    u′, s′, v′ = svd_trunc(Matrix(a); trunc=(; maxrank=6))
-    @test Matrix(u * s * v) ≈ u′ * s′ * v′
-    @test arguments(u, 2) isa Eye{elt}
-    @test arguments(s, 2) isa Eye{real(elt)}
-    @test arguments(v, 2) isa Eye{elt}
-    @test size(u) == (9, 6)
-    @test size(s) == (6, 6)
-    @test size(v) == (6, 9)
-  end
+  ## TODO: Need to implement truncation.
+  ## for elt in (Float32, ComplexF32)
+  ##   a = randn(elt, 3, 3) ⊗ δ(elt, 3, 3)
+  ##   # TODO: Type inference is broken for `svd_trunc`,
+  ##   # look into fixing it.
+  ##   # u, s, v = @constinferred svd_trunc(a; trunc=(; maxrank=7))
+  ##   u, s, v = svd_trunc(a; trunc=(; maxrank=7))
+  ##   @test eltype(u) === elt
+  ##   @test eltype(s) === real(elt)
+  ##   @test eltype(v) === elt
+  ##   u′, s′, v′ = svd_trunc(Matrix(a); trunc=(; maxrank=6))
+  ##   @test Matrix(u * s * v) ≈ u′ * s′ * v′
+  ##   @test arguments(u, 2) isa DeltaMatrix{elt}
+  ##   @test arguments(s, 2) isa DeltaMatrix{real(elt)}
+  ##   @test arguments(v, 2) isa DeltaMatrix{elt}
+  ##   @test size(u) == (9, 6)
+  ##   @test size(s) == (6, 6)
+  ##   @test size(v) == (6, 9)
+  ## end
 
-  a = Eye(3, 3) ⊗ Eye(3, 3)
-  @test_throws ArgumentError svd_trunc(a)
+  a = δ(3, 3) ⊗ δ(3, 3)
+  @test_broken svd_trunc(a)
 
   # svd_vals
   for elt in (Float32, ComplexF32)
-    a = Eye{elt}(3, 3) ⊗ randn(elt, 3, 3)
+    a = δ(elt, 3, 3) ⊗ randn(elt, 3, 3)
     d = @constinferred svd_vals(a)
     d′ = svd_vals(Matrix(a))
     @test sort(Vector(d); by=abs) ≈ sort(d′; by=abs)
@@ -229,7 +233,7 @@ herm(a) = parent(hermitianpart(a))
   end
 
   for elt in (Float32, ComplexF32)
-    a = randn(elt, 3, 3) ⊗ Eye{elt}(3)
+    a = randn(elt, 3, 3) ⊗ δ(elt, 3, 3)
     d = @constinferred svd_vals(a)
     d′ = svd_vals(Matrix(a))
     @test sort(Vector(d); by=abs) ≈ sort(d′; by=abs)
@@ -238,38 +242,42 @@ herm(a) = parent(hermitianpart(a))
   end
 
   for elt in (Float32, ComplexF32)
-    a = Eye{elt}(3) ⊗ Eye{elt}(3)
+    a = δ(elt, 3, 3) ⊗ δ(elt, 3, 3)
     d = @constinferred svd_vals(a)
-    @test d == Ones(3) ⊗ Ones(3)
+    @test d ≡ Ones{real(elt)}(3) ⊗ Ones{real(elt)}(3)
     @test arguments(d, 1) isa Ones{real(elt)}
     @test arguments(d, 2) isa Ones{real(elt)}
   end
 
   # left_null
-  a = Eye(3, 3) ⊗ randn(3, 3)
-  n = @constinferred left_null(a)
-  @test norm(n' * a) ≈ 0
-  @test arguments(n, 1) isa Eye
+  a = δ(3, 3) ⊗ randn(3, 3)
+  @test_broken left_null(a)
+  ## n = @constinferred left_null(a)
+  ## @test norm(n' * a) ≈ 0
+  ## @test arguments(n, 1) isa DeltaMatrix
 
-  a = randn(3, 3) ⊗ Eye(3, 3)
-  n = @constinferred left_null(a)
-  @test norm(n' * a) ≈ 0
-  @test arguments(n, 2) isa Eye
+  a = randn(3, 3) ⊗ δ(3, 3)
+  @test_broken left_null(a)
+  ## n = @constinferred left_null(a)
+  ## @test norm(n' * a) ≈ 0
+  ## @test arguments(n, 2) isa DeltaMatrix
 
-  a = Eye(3) ⊗ Eye(3)
-  @test_throws MethodError left_null(a)
+  a = δ(3, 3) ⊗ δ(3, 3)
+  @test_broken left_null(a)
 
   # right_null
-  a = Eye(3) ⊗ randn(3, 3)
-  n = @constinferred right_null(a)
-  @test norm(a * n') ≈ 0
-  @test arguments(n, 1) isa Eye
+  a = δ(3, 3) ⊗ randn(3, 3)
+  @test_broken right_null(a)
+  ## n = @constinferred right_null(a)
+  ## @test norm(a * n') ≈ 0
+  ## @test arguments(n, 1) isa DeltaMatrix
 
-  a = randn(3, 3) ⊗ Eye(3)
-  n = @constinferred right_null(a)
-  @test norm(a * n') ≈ 0
-  @test arguments(n, 2) isa Eye
+  a = randn(3, 3) ⊗ δ(3, 3)
+  @test_broken right_null(a)
+  ## n = @constinferred right_null(a)
+  ## @test norm(a * n') ≈ 0
+  ## @test arguments(n, 2) isa DeltaMatrix
 
-  a = Eye(3) ⊗ Eye(3)
-  @test_throws MethodError right_null(a)
+  a = δ(3, 3) ⊗ δ(3, 3)
+  @test_broken right_null(a)
 end
diff --git a/test/test_matrixalgebrakit.jl b/test/test_matrixalgebrakit.jl
index 8bf4e3e..adc6974 100644
--- a/test/test_matrixalgebrakit.jl
+++ b/test/test_matrixalgebrakit.jl
@@ -34,7 +34,7 @@ herm(a) = parent(hermitianpart(a))
   @test a * v ≈ v * d
 
   a = randn(elt, 2, 2) ⊗ randn(elt, 3, 3)
-  @test_throws MethodError eig_trunc(a)
+  @test_throws ArgumentError eig_trunc(a)
 
   a = randn(elt, 2, 2) ⊗ randn(elt, 3, 3)
   d = eig_vals(a)
@@ -47,7 +47,7 @@ herm(a) = parent(hermitianpart(a))
   @test eltype(v) === elt
 
   a = herm(randn(elt, 2, 2)) ⊗ herm(randn(elt, 3, 3))
-  @test_throws MethodError eigh_trunc(a)
+  @test_throws ArgumentError eigh_trunc(a)
 
   a = herm(randn(elt, 2, 2)) ⊗ herm(randn(elt, 3, 3))
   d = eigh_vals(a)
@@ -121,7 +121,7 @@ herm(a) = parent(hermitianpart(a))
   @test collect(v * v') ≈ I
 
   a = randn(elt, 2, 2) ⊗ randn(elt, 3, 3)
-  @test_throws MethodError svd_trunc(a)
+  @test_throws ArgumentError svd_trunc(a)
 
   a = randn(elt, 2, 2) ⊗ randn(elt, 3, 3)
   s = svd_vals(a)