Conversion of `Block` to `Tuple`

[mtfishman]

It would be nice to be able to convert a Block to a Tuple. Of course it leaves the question of whether it should convert to a tuple of Integer or Block{1}. I would vote for the latter but I could see arguments either way.

This would be analagous to:

julia> Tuple(CartesianIndex(2, 2))
(2, 2)

in Base, so either:

julia> using BlockArrays

julia> Base.Tuple(b::Block) = b.n
Tuple

julia> Tuple(Block(2, 2))
(2, 2)

or:

julia> Base.Tuple(b::Block) = Block.(b.n)
Tuple

julia> Tuple(Block(2, 2))
(Block(2), Block(2))

There are a number of places in the source code where the definition Base.Tuple(b::Block) = Block.(b.n) would be useful, for example:

BlockArrays.jl/src/views.jl

Line 152 in d113dd3

k, j = b.n

BlockArrays.jl/src/views.jl

Line 35 in d113dd3

to_indices(A, inds, (Block.(I[1].n)..., tail(I)...))

BlockArrays.jl/src/blockindices.jl

Line 44 in d113dd3

Block{N, T}(ntuple(i -> blocks[i].n[1], Val(N)))

BlockArrays.jl/src/pseudo_blockarray.jl

Line 240 in d113dd3

range = getindex.(axes(block_arr), Block.(block.n))

It seems common to want a Tuple of Block{1} so perhaps that could guide the design choice (also that it loses less information about the input, so is closer in spirit to a conversion).

[jishnub]

Currently, a convert method exists, so a constructor consistent with this might make sense:

julia> b = Block(2,2)
Block(2, 2)

julia> convert(Tuple, b)
(2, 2)

[mtfishman]

Thanks for pointing that out. I could see an argument that both should return (Block(2), Block(2)), for the practical reason that seems to be the most common way that conversion is used in the library and in my own use cases. But it does make sense to try to make them consistent.

I suppose whatever the default behavior is, the conversions can be spelled out more explicitly:

julia> convert(Tuple{Vararg{Integer}}, Block(2, 2))
(2, 2)

julia> Tuple{Vararg{Integer}}(Block(2, 2))
(2, 2)

julia> convert(Tuple{Vararg{Block{1}}}, Block(2, 2))
(Block(2), Block(2))

julia> Tuple{Vararg{Block{1}}}(Block(2, 2))
(Block(2), Block(2))

(where it might be useful to make a typedef const BlockTuple{N,T} = NTuple{N,Block{1,T}}).

Oddly that constructor syntax doesn't work for CartesianIndex:

julia> convert(Tuple{Vararg{Float64}}, CartesianIndex(2, 2))
(2.0, 2.0)

julia> Tuple{Vararg{Float64}}(CartesianIndex(2, 2))
ERROR: iteration is deliberately unsupported for CartesianIndex. Use `I` rather than `I...`, or use `Tuple(I)...`
Stacktrace:
 [1] error(s::String)
   @ Base ./error.jl:35
 [2] iterate(#unused#::CartesianIndex{2})
   @ Base.IteratorsMD ./multidimensional.jl:158
 [3] copyto!(dest::Vector{Float64}, src::CartesianIndex{2})
   @ Base ./abstractarray.jl:948
 [4] _collect(#unused#::Type{Float64}, itr::CartesianIndex{2}, isz::Base.HasLength)
   @ Base ./array.jl:644
 [5] collect(#unused#::Type{Float64}, itr::CartesianIndex{2})
   @ Base ./array.jl:642
 [6] _totuple(::Type{Tuple{Vararg{Float64}}}, ::CartesianIndex{2})
   @ Base ./tuple.jl:399
 [7] Tuple{Vararg{Float64}}(itr::CartesianIndex{2})
   @ Base ./tuple.jl:369
 [8] top-level scope
   @ REPL[12]:1

[dlfivefifty]

I agree with @mtfishman: convert should not change the "meaning" of a tyep.

[mtfishman]

Happy to make a PR introducing Tuple(::Block) and also changing convert(::Type{<:Tuple}, ::Block).

[jishnub]

Please make a PR, this will also let us see if there are obvious downstream breakages

[mtfishman]

Ok I made a PR (#318).