use dictionary as named arguments for function

[Westley Hennigh]

I hope I'm being dense and that this already exists.

I have some pre-named-args julia which -effectively- flattens a dictionary of named things into an ordered tuple of args that are passed into a function. I'd really like to just use the dictionary as a set of named args. Is that possible?

[Mike Nolta]

```
julia> f(;kw...) = for (k,v) in kw; println(k,",",v); end
# methods for generic function f
f() at none:1

julia> d = {:a => 1, :b => "c"}
{:b=>"c",:a=>1}

julia> f(;d...)
b,c
a,1
```

-Mike

[Westley Hennigh]

Heh, ya, but I can always pass a dictionary. It would be sweet if the names could be broken out so that you can read the defaults and we don't end up with big blocks of `get(args, thing, default)` at the top of functions.

[Mike Nolta]

```
julia> f(;x=0,y=0) = (x,y)

# methods for generic function f
f() at none:1

julia> d = {:x => 3, :y => 4}
{:y=>4,:x=>3}

julia> f(;d...)
(3,4)
```

-Mike

On Mon, Aug 5, 2013 at 8:02 PM, Westley Hennigh

[Westley Hennigh]

Lol. I apologize for taking your time, thanks!

[Westley Hennigh]

Ok, I have -perhaps- a slightly more interesting question based on this.

In your above example, suppose you have a dict `d = {"x" => 3, "y" => 4}`. Note the strings.

If you called your function f with said dict, I think (could be wrong) that what you're after is pretty unambiguous (to treat the strings as symbols). What's more, I think that the conversion between strings and symbols can be pretty cheap.

So maybe we could add support for more efficiently calling functions with dictionaries of strings of named args (without generating one containing symbols).

I see line 429 in https://github.com/JuliaLang/julia/blob/master/src/julia-syntax.scm, I think dictionaries are being expanded around like 1670 and then passed as an unsorted list. So maybe this wouldn't be more efficient... Not sure, are you more familiar with this code?

[Westley Hennigh]

I'm wrong about the purpose of the code at 1670

[Jacob Quinn]

Auto-converting strings to symbols in this case seems pretty auto-magical (in a bad way). I would just expect the user to call the symbol(x) call themselves before passing them in.

-Jacob

[Westley Hennigh]

Hmm, maybe it is. I'm a partial judge.

But just to be clear: I don't want to actually modify the dict or pursue this if it will be considerably slower.

I do think it's fairly unambiguous. And if you pulled a dictionary out of some json and wanted to use it as parameters, I think this would seem pretty straightforward / convenient.

[Elliot Saba]

One of the problems with this is that strings have quite a bit more leeway in what they can contain than symbols.  What happens if your strings have spaces?  Or minus symbols?  Getting an error from the `symbol()` function while trying to splat a dictionary seems like it might be confusing.

If doing this conversion automatically wouldn't take too much cpu time, then doing it manually won't take too much cpu time either.  :)  It should be pretty straightfoward to write e.g. a `dictsplat()` function that converts any string keys to symbols, and throws a meaningful error if they are unable to do so.

[Westley Hennigh]

The problem with error handling hadn't occurred to me - This was a bad idea.

Thanks all! Sorry for the noise.

[Ivar Nesje]

What is the problem with having minus or space in a symbol? You'd have to generate the code using Expr() and symbol("var-with minus&space"), as the parser uses those characters as delimiters when it parses code. Errors should be given when you use a dictionary with keys that does not match the keyword arguments of the function, so there is no reason to give a different error if some of the characters should be invalid.

Ivar

[Westley Hennigh]

I think the issue is transparency for the user. If they have a dictionary and get an error when they call (I kind of like Elliot's name) `dictsplat()`, it's pretty obvious what the problem is. If they just use the dictionary of strings and we do the conversion for them it might not be as clear.

[Jeff Bezanson]

Although converting a string to a symbol is reasonably efficient, it's too much extra work to do for something like a function call where every cycle counts. You could easily end up doing this work repeatedly, for each one of many calls. It also might lead somebody to think strings are equally valid in this context, and use them exclusively, which I would consider a performance trap.

[Edward Chen]

To whom it may concern:

I am having trouble adding elements to my dictionary and then passing it into a function:

function f(;kw...)

    for (k,v) in kw

        println(k,",",v)

    end

end 

d = {:a => 1, :b => "c"} # this works

# d = Dict() # but this line

# d["d"] = 2 # with this fails

f(;d...)

Thanks,

Ed

[Peter Brady]

I believe you want

d[:d] = 2

Peter.

[Edward Chen]

Ah yeah that works!

The wikibooks documentation is wrong then, maybe i'll correct it:

http://en.wikibooks.org/wiki/Introducing_Julia/Dictionaries_and_sets