The short answer is that you cannot create an empty tuple of type Tuple{Int,Int}. By definition, a Tuple{Int, Int} has a length of 2 and is thus not empty.
Compare this to an empty Array{Int} which can have a length of 0 and is thus empty:
julia> empty_array = Int[]
Int64[]
julia> isempty(empty_array)
true
julia> length(empty_array)
0
The long answer is it depends what you mean by "empty". Perhaps you mean something that you did not have to initialize. We can partly investigate this using a Ref. In this case the values will be whatever is resident in memory. Overall, I'm not sure what advantage this would have over just initializing the tuple as (0,0).
julia> r = Ref{Tuple{Int,Int}}()
Base.RefValue{Tuple{Int64, Int64}}((2, 139735268818544))
julia> r = Ref{Tuple{Int,Int}}()
Base.RefValue{Tuple{Int64, Int64}}((139735268745904, 139735268746800))
julia> isempty(r[])
false
It is not clear to me overall why you want an empty tuple other than as a default initial value for a default myStruct constructor.
For a default constructor, I recommend using (0,0) as the initial value:
julia> mutable struct myStruct
info::Tuple{Int, Int}
end
julia> myStruct() = myStruct((0,0))
myStruct
julia> myStruct()
myStruct((0, 0))
My last guess at why you might want an "empty" tuple is to avoid allocations. Creating a myStruct instance results in a 32 byte allocation. To avoid allocations, the best course of action would be to make the struct immutable. Doing so comes with a multitude of advantages such as simplified memory layout involving less pointer indirection. It also allows the compiler to make simplifying assumptions resulting in faster code.
julia> @time myStruct();
0.000001 seconds (1 allocation: 32 bytes)
julia> struct NonAllocatingStruct
info::Tuple{Int, Int}
end
julia> NonAllocatingStruct() = NonAllocatingStruct((0,0))
NonAllocatingStruct
julia> @time NonAllocatingStruct()
0.000002 seconds
NonAllocatingStruct((0, 0))