There's a package called https://github.com/JuliaCollections/OrderedCollections.jl that implements OrderedDict and OrderedSet and now this package implements DispatchedTuple and DispatchedSet so I was wondering if the name DispatchedCollections.jl made sense or maybe it's too general?

The first thing I tried (because I didn't read the README carefully enough) was

dt = DispatchedTuple(Center() => "c", Face() => "f")

which didn't work because the input needs to be a tuple of pairs.

Would it helpful to users to define a constructor like

julia> DispatchedTuple(multiple_pairs...) = DispatchedTuple(Tuple(multiple_pairs))

so that the initial example works:

julia> dt = DispatchedTuple(Center() => "c", Face() => "f")
DispatchedTuple{Tuple{Tuple{Center, String}, Tuple{Face, String}}, DispatchedTuples.NoDefaults}(((Center(), "c"), (Face(), "f")), DispatchedTuples.NoDefaults())

Seems like other packages like to show off how short the generated LLVM or assembly code is to show that the code generated is performant. Is it worth adding something similar for DispatchedTuples.jl?

I'm not too familiar with @generated so I played around to see if the generated code was indeed concise. Looks like it is!

DispatchedSet

julia> ds = DispatchedSet((Center() => "c", Face() => :f))
DispatchedSet{Tuple{Tuple{Center, String}, Tuple{Face, Symbol}}, DispatchedTuples.NoDefaults}(((Center(), "c"), (Face(), :f)), DispatchedTuples.NoDefaults())

julia> @code_native dispatch(ds, Face())
        .text
; ┌ @ DispatchedTuples.jl:147 within `dispatch'
; │┌ @ DispatchedTuples.jl within `macro expansion'
; ││┌ @ tuple.jl:29 within `getindex'
        movq    8(%rdi), %rax
; ││└
        retq
        nopw    %cs:(%rax,%rax)
; └└

julia> @code_native dispatch(ds, Center())
        .text
; ┌ @ DispatchedTuples.jl:147 within `dispatch'
; │┌ @ DispatchedTuples.jl within `macro expansion'
; ││┌ @ tuple.jl:29 within `getindex'
        movq    (%rdi), %rax
; ││└
        retq
        nopw    %cs:(%rax,%rax)
; └└

DispatchedTuple

julia> dt = DispatchedTuple((Center() => "c", Face() => "f", Center() => :c, Face() => :f))
DispatchedTuple{Tuple{Tuple{Center, String}, Tuple{Face, String}, Tuple{Center, Symbol}, Tuple{Face, Symbol}}, DispatchedTuples.NoDefaults}(((Center(), "c"), (Face(), "f"), (Center(), :c), (Face(), :f)), DispatchedTuples.NoDefaults())

julia> @code_native dispatch(dt, Center())
        .text
; ┌ @ DispatchedTuples.jl:107 within `dispatch'
        movq    %rdi, %rax
; │┌ @ DispatchedTuples.jl:24 within `macro expansion'
; ││┌ @ tuple.jl:29 within `getindex'
        movq    (%rsi), %rcx
        movq    16(%rsi), %rdx
; ││└
        movq    %rcx, (%rdi)
        movq    %rdx, 8(%rdi)
        retq
        nopw    %cs:(%rax,%rax)
; └└

julia> @code_native dispatch(dt, Face())
        .text
; ┌ @ DispatchedTuples.jl:107 within `dispatch'
        movq    %rdi, %rax
; │┌ @ DispatchedTuples.jl:24 within `macro expansion'
; ││┌ @ tuple.jl:29 within `getindex'
        movq    8(%rsi), %rcx
        movq    24(%rsi), %rdx
; ││└
        movq    %rcx, (%rdi)
        movq    %rdx, 8(%rdi)
        retq
        nopw    %cs:(%rax,%rax)
; └└

Right now, when passing a tuple to DispatchedTuple/DispatchedSet, we store the entire tuple, but since DispatchedTuple kind of compresses the values (into a single tuple), we could compress the storage of the keys.

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

I noticed that indexing a DispatchedTuple always returns a tuple:

julia> dispatch(dt, Center())
("c",)

which I thought might introduce lots of [1] boilerplate if I used it since I usually want the contents of the 1-tuple

julia> dispatch(dt, Center())[1]
"c"

but maybe this is because I'm focusing on the case where each object maps to just one value.

Is it always returning a tuple because you want the type of the output to always be <:Tuple? I guess returning [1] in the case of a 1-tuple might introduce type instability?

I guess ignoring the README I was kind of hoping getindex would just work.

julia> dt = DispatchedTuple((Center() => "c", Face() => "f"))
DispatchedTuple{Tuple{Tuple{Center, String}, Tuple{Face, String}}, DispatchedTuples.NoDefaults}(((Center(), "c"), (Face(), "f")), DispatchedTuples.NoDefaults())

julia> dt[Center()]
ERROR: MethodError: no method matching getindex(::DispatchedTuple{Tuple{Tuple{Center, String}, Tuple{Face, String}}, DispatchedTuples.NoDefaults}, ::Center)
Stacktrace:
 [1] top-level scope
   @ REPL[3]:1

Turns out it's just a one-liner!

julia> import Base: getindex

julia> getindex(dt::DispatchedTuple, e) = dispatch(dt, e)
getindex (generic function with 372 methods)

julia> dt[Center()]
("c",)

julia> dt[Face()]
("f",)