# Concatenation on matrix-like types on 0.7

#1

I think this commit broke LinearOperators here. Essentially, making `[A B; C]` calls something different on 0.7, and doesn’t work with the default `hcat` and `vcat`.

A workaround would be to define `hvcat` for `LinearOperators`, but I’m wondering if this problem may affect other people, and if there is a better workaround.

MWE:

``````mutable struct DummyMatrix
rows :: Int
cols :: Int
end

import Base.size
function size(A :: DummyMatrix)
return (A.rows, A.cols)
end

import Base.hcat
function hcat(As :: DummyMatrix...)
A = As[1]
for i = 2:length(As)
A = hcat(A, As[i])
end
return A
end

function hcat(A :: DummyMatrix, B :: DummyMatrix)
@assert A.rows == B.rows
DummyMatrix(A.rows, A.cols + B.cols)
end

import Base.vcat
function vcat(As :: DummyMatrix...)
A = As[1]
for i = 2:length(As)
A = vcat(A, As[i])
end
return A
end

function vcat(A :: DummyMatrix, B :: DummyMatrix)
@assert A.cols == B.cols
DummyMatrix(A.rows + B.rows, A.cols)
end

function foo()
A = DummyMatrix(2,2)
B = DummyMatrix(2,2)
C = DummyMatrix(2,4)
println([A B; C])
end

foo()
``````

#2

There appears to be a detour through a `Vector{Any}` which doesn’t propagate the size information as you might hope.

Can you use `[[A B]; C]` instead?

#3

Yes, `[[A B]; C]` results in the correct `LinearOperator`, but we want `LinearOperator` to closely resemble matrices when possible, and the “fallback definition of hvcat in terms of hcat and vcat” (Line 1532) was very useful here.

Does this affect anyone else?