Add method +(a::Tuple, b::Tuple)

[milktrader]

Concatenating two tuples in Python is simple

In [1]: a = (1,2)

In [2]: b = (3,4)

In [3]: a+b
Out[3]: (1, 2, 3, 4)

Julia though doesn't have this as a method

julia> a = (1,2)
(1,2)

julia> b = (3,4)
(3,4)

julia> a+b
ERROR: no method +((Int64,Int64),(Int64,Int64))

In fact, I still haven't figured out a hack on how to do it.

[pao]

tuple((1,2)...,(3,4)...)

Would prefer this to be * if we do this at all--tuples are a product of types, after all (for instance, Int*Float = (Int, Float). But I'm not sure that it's necessary of whether this should be encouraged.

[diegozea]

People can guess something like:
(1,2) + (3,4) = (4,6)
Using * is a little better because is explained for Strings concatenation.
+ looks a easy to read option to me for Strings (but not for tuple). For Strings + have some problems (problems like pao mentioned on his last sentence but with Char)
#2301
#1771

[diegozea]

What about define cat in a different way for tuples?
Now we have:

julia> vcat((1,2),(3,4))
2-element (Any...,) Array:
 (1,2)
 (3,4)

julia> cat((1,2),(3,4))
ERROR: no method cat((Int64,Int64),(Int64,Int64))

julia> hcat((1,2),(3,4))
1x2 (Any...,) Array:
 (1,2)  (3,4)

[milktrader]

hcat and vcat do not achieve a single tuple but rather an array of tuples

[milktrader]

Thanks @pao, it works to do

tuple(a...,b...)

I'll leave this issue open so a decision can be made on whether or not to add a new method

[StefanKarpinski]

This definitely shouldn't be a method of + since [1,2]+[3,4] == [4,6]. I guess we could make a * method, but you really mostly shouldn't be doing much computation with tuples in the first place, so I'm really reluctant to do this. Also, given the whole * string concatenation history, I'm reluctant to start cramming another meaning in there.

[JeffBezanson]

The dots are the official way to do this.

[newguise1234]

I know this is closed, but if the method *(Tuple,Tuple) was added as concatenation, then it could be used for matrices of tuples, ie. [(1,);(2,);(3,);(4,)] * [(1,),(2,),(3,),(4,)] to give a 4x4 matrix with associated indices in each spot. Feel free to reject this.

[newguise1234]

This is the code that I'm using in my program. Even if it isn't implemented, maybe people will see it here if they need the functionality.

function *(t1::Tuple,t2::Tuple)
  return tuple(t1...,t2...)
end

function matrix_indices(dims::Tuple)
  m = Array(Tuple,tuple(dim[1],1))
  m[:] = map(tuple,[1:dims[1]])
  for i in dims[2:end]
    t = Array(Tuple,(1,i))
    t[:] = map(tuple,[1:i])
    m = reshape(m,(length(m),1))
    m *= t
  end
  return reshape(m,(dims))
end

[lindahua]

@newguise1234 Whereas I think [(1,);(2,);(3,);(4,)] * [(1,),(2,),(3,),(4,)] is a clear trick, this is not idiomatic Julia and not a very efficient way for large matrix.

To generate a matrix of index tuples, the following way is recommended

[(i, j) for i = 1:m, j=1:n]

It is concise, efficient, and easier to understand.

[mbauman]

There's an interesting side-effect to defining tuple arithmetic that makes it marginally terrifying:

julia> import Base.*
       *(x::Tuple, y::Number) = map(i->i*y, x) # Shoddy, simplistic definitions
       *(x::Tuple, y::Tuple) = map(*, x, y)
* (generic function with 165 methods)

julia> a = b = 3
3

julia> a, b *= 2
(6,6)

julia> a, b *= 2, 3
(12,18)

Concatenation would be even stranger.