Ggtcf

I would like to find a succinct syntax in Julia for indexing a dictionary in a vectorized manner. In R, I would do the following:

dict <- c("a" = 1, "b" = 2)
keys <- c("a", "a", "b", "b", "a")
dict[keys]

In Julia, if I have a dict and keys like this,

dict = Dict(:a => 1, :b => 2)
keys = [:a, :a, :b, :b, :a]

then I can achieve the desired result using a list comprehension:

julia> [dict[key] for key in keys]
5-element ArrayInt64,1:
 1
 1
 2
 2
 1

Is there a more succinct vectorized syntax, similar to the R syntax?

getindex.(Ref(dict), keys)

You can wrap it in Ref so you don't need to [] it.

Here's a little macro (using the brilliant MacroTools package):

using MacroTools
macro vget(ex)
 @capture(ex, dict_.[idxvec_])
 :(map(i->$dict[i], $idxvec)) |> esc
end

Then you can:

d = Dict(:a => 1, :b => 2)
ks = [:a, :a, :b, :b, :a]

@vget d.[ks]

I probably wouldn't want to use that in production code, something like your list comprehension, or a simple map: map(i->d[i], ks), is more readable/explicit/standard, but it is fun :D

If you're going to be frequently using the dictionary as a lookup table, then it might be worth creating a closure to use as a lookup function:

make_lookup(dict) = key -> dict[key] 

dict = Dict(:a => 1, :b => 2)

lookup = make_lookup(dict)

Then you can use lookup in a vectorized fashion:

julia> keys = [:a, :a, :b, :b, :a];

julia> lookup.(keys)
5-element ArrayInt64,1:
 1
 1
 2
 2
 1

You can use the vectorized version of getindex:

julia> getindex.([dict], keys)
5-element ArrayInt64,1:
 1
 1
 2
 2
 1

Note that dict is wrapped in an array so that getindex does not attempt to broadcast over the elements of the dictionary:

julia> getindex.(dict, keys)
ERROR: ArgumentError: broadcasting over dictionaries and `NamedTuple`s is reserved
Stacktrace:
 [1] broadcastable(::DictSymbol,Int64) at ./broadcast.jl:615
 [2] broadcasted(::Function, ::DictSymbol,Int64, ::ArraySymbol,1) at ./broadcast.jl:1164
 [3] top-level scope at none:0