charleskawczynski / dispatchedtuples.jl Goto Github PK
View Code? Open in Web Editor NEWDispatched tuples
License: MIT License
Dispatched tuples
License: MIT License
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())
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?
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)
; └└
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?
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 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",)
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.
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google ❤️ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.