I have nested tuples like

```
tup = Tuple{Tuple{Int64,Int8},Tuple{Int128,Int32}}
```

and I need to find the largest eltype of the elements, i.e. `Int128`

in the above case. I feel I need to use `promote_type`

in a recursive fashion, but my attempts have failed so far.

Thanks!

What are your attempts so far?

I think I got it. Here it is

```
using Base.Test
promote_tuple_type(a::Number) = typeof(a)
promote_tuple_type(a::Tuple) = promote_type(map(promote_tuple_type, a)...)
# basic tests
tup0 = ((1, 1), (1, 2), (2, 3), (2, 3, 4), ((2, 3, (3, 4, (5, 5, (1,))))))
tup1 = ((Int8(1), Int32(1)), (Int64(1), Float64(1)))
tup2 = ((Int8(1), Int32(1)), (Int64(1), Int128(1)))
tup3 = (((Int8(1), Int32(1)), (Int64(1), Int128(1))), (Float32(1), Float16(1)))
@test promote_tuple_type(tup0) == Int64
@test promote_tuple_type(tup1) == Float64
@test promote_tuple_type(tup2) == Int128
@test promote_tuple_type(tup3) == Float32
```

This works well, but maybe there is better way of doing it.

1 Like

The related problem is to construct a new tuple where all elements have the same type. I came up with two options

```
convert_tuple{T}(::Type{T}, a::Number) = T(a)
convert_tuple{T}(::Type{T}, a::Tuple) = (map(el->convert_tuple(T, el), a)...)
convert_tuple{T}(::Type{T}, a::Tuple) = (convert_tuple.(T, a)...)
```

The second looks nicer but incurs in more allocations than the first.

These works OK for me, but again, there might be a better way of doing it.