This is a neat solution, thanks! But I still think that there is a
corner case for which there is no syntax, so I filed #15758.
Best,
Tamas
On Mon, Apr 04 2016, via julia-users wrote:
> I saw your repost on julia-dev, but replying here.
>
> m2 won't work because it expects a series of tuple arguments (which if
> supplied would slurp up into a tuple of tuples).
>
> m3 seems the way to go.
>
> I wouldn't necessarily look at it as indirect however.
> Think of it as one function with 2 methods: one version is for a single
> tuple argument, the other is for the equivalent expressed as
> multiple arguments.
> Also, you can define the 2 versions as m3 rather than m3 and _m3.
>
> In fact you could use dispatch to add error processing with a third method:
>
> module Foos
> type Foo{T <: Tuple}
> end
> m4{T<:Tuple}(f::Foo{T}, index::Tuple) = error("expected index type $T,
> got $(typeof(index))")
> m4{T<:Tuple}(f::Foo{T}, index::T) = 42
> m4(f::Foo, index...) = m4(f, index)
> end
>
> f1 = Foos.Foo{Tuple{Int}}()
> Foos.m4(f1, 9)
>
> f2 = Foos.Foo{Tuple{Int,Symbol}}()
> Foos.m4(f2, (9, :a))
> Foos.m4(f2, 9, :a)
>
> Foos.m4(f2, (9.0, :a)) # error, wrong types
> Foos.m4(f2, 9.0, :a) # error, wrong types
>
>
>
> On Thursday, March 31, 2016 at 1:41:56 AM UTC+11, Tamas Papp wrote:
>
>> Hi Bill,
>>
>> It works for a single argument, but not for multiple ones. I have a
>> self-contained example:
>>
>> --8<---------------cut here---------------start------------->8---
>> module Foos
>>
>> type Foo{T <: Tuple}
>> end
>>
>> m1{T}(f::Foo{Tuple{T}}, index::T...) = 42 # suggested by Bill Hart
>>
>> m2{T}(f::Foo{T}, index::T...) = 42 # what I thought would work
>>
>> _m3{T}(f::Foo{T}, index::T) = 42 # indirect solution
>> m3{T}(f::Foo{T}, index...) = _m3(f, index)
>>
>> end
>>
>> f1 = Foos.Foo{Tuple{Int}}()
>>
>> Foos.m1(f1, 9) # works
>> Foos.m2(f1, 9) # won't work
>> Foos.m3(f1, 9) # works
>>
>> f2 = Foos.Foo{Tuple{Int,Symbol}}()
>>
>> Foos.m1(f2, 9, :a) # won't work
>> Foos.m2(f2, 9, :a) # won't work
>> Foos.m3(f2, 9, :a) # indirect, works
>> --8<---------------cut here---------------end--------------->8---
>>
>> For more than one argument, only the indirect solution works.
>>
>> Best,
>>
>> Tamas
>>
>> On Wed, Mar 23 2016, via julia-users wrote:
>>
>> > The following seems to work, but I'm not sure whether it was what you
>> > wanted:
>> >
>> > import Base.getindex
>> >
>> > type Foo{T <: Tuple}
>> > end
>> >
>> > getindex{T}(f::Foo{Tuple{T}}, index::T...) = 42
>> >
>> > Foo{Tuple{Int}}()[9]
>> >
>> > Bill.
>> >
>> > On Wednesday, 23 March 2016 14:38:20 UTC+1, Tamas Papp wrote:
>> >>
>> >> Hi,
>> >>
>> >> My understanding was that ... in a method argument forms a tuple, but I
>> >> don't know how to dispatch on that. Self-contained example:
>> >>
>> >> import Base.getindex
>> >>
>> >> type Foo{T <: Tuple}
>> >> end
>> >>
>> >> getindex{T}(f::Foo{T}, index::T...) = 42
>> >>
>> >> Foo{Tuple{Int}}()[9] ## won't match
>> >>
>> >> ## workaround with wrapper:
>> >>
>> >> _mygetindex{T}(f::Foo{T}, index::T) = 42
>> >> mygetindex{T}(f::Foo{T}, index...) = _mygetindex(f, index)
>> >>
>> >> mygetindex(Foo{Tuple{Int}}(), 9)
>> >>
>> >> Is it possible to make it work without a wrapper in current Julia?
>> >>
>> >> Best,
>> >>
>> >> Tamas
>> >>
>>
>>
