Can you give a little more context for what you’re trying to do? I’m not clear on the various behaviors you want from the different `timespace` variants.
I’m actually not sure whether the order can be relied on, but I think the proposed API might be confusing for users of your function because most people assume keyword argument order doesn’t matter. My guess is that with a little more info on what you’re trying to accomplish we could help find a more idiomatic solution. -s > On Nov 12, 2015, at 4:19 PM, MA Laforge <ma.laforge...@gmail.com> wrote: > > Hi users, > > I want to be able to generate ranges using a syntax similar to: > t1=timespace(tstart = 2e-9, ts=1e-9, tfund=20e-9); > t11=timespace(fs=1/1e-9, tfund=20e-9, tstart=3e-9); > t2=timespace(tfund=20e-9, tstart=4e-9, ts=1e-9); > > Why not just use different function names? > Simply put, I would rather not have to use long, ugly names like (timespace1, > timespace2, timespace_tfund, timespace_ts, timespace_fs, ...) > > What is unusual/difficult about this solution: > linspace uses "number of points" - presumably because specifying both > timespan, and timestep might result in non-integer number of points (poorly > defined). > So... in this case, I want timespace to use the first argument (ignoring > tstart) to dictate which algorithm to select. For example: with > timespace(ts=1, tfund=20.5), the sampling period, ts is assumed to be exact, > and the fundamental period (tfund) will be adjusted to get an integer number > of points. > It would be preferable to use Juila's dispatch system to dispatch on the > keyword names (which it does not - at least not directly). > Since all arguments here are keywords, Julia will only support a single > master function "timespace(; kwargs...)". > Attempted Solution > I have a solution, but it depends on keyword ordering... and I don't know if > this is a dangerous thing to do: I believe keyword ordering is *not* > guaranteed. > > Anyways, here is the solution... > #Dispatchable keyword type (make name short - expect heavy use) > immutable KD{Symbol}; end #Not kraft dinner > > #Convert kwargs to a list of dispatchable elements: > function dispatchable(kwargs::Vector{Any}) > result = Any[] for (k,v) in kwargs > push!(result, KD{k}()) > push!(result, v) > end > return result > end > > timespace() = throw("timespace requires arguments") > timespace(;tstart=0, kwargs...) = > timespace(dispatchable(kwargs)..., tstart=tstart) > > function timespace(::KD{:ts}, ts, ::KD{:tfund}, tfund; tstart=0) > println("FUNCTION1 (priority on ts): ts=$ts, tfund=$tfund, > tstart=$tstart") > end > > #Similar to previous, but expects fs = 1/ts > function timespace(::KD{:fs}, fs, ::KD{:tfund}, tfund; tstart=0) > println("FUNCTION1.1 (priority on fs): fs=$fs, tfund=$tfund, > tstart=$tstart") > end > > function timespace(::KD{:tfund}, tfund, ::KD{:ts}, ts; tstart=0) > println("FUNCTION2 (priority on tfund): tfund=$tfund, ts=$ts, > tstart=$tstart") > end > > This solution works (for the time being). The generic timespace(;kwargs...) > function catches all the keyword argument, and converts the to normal > arguments. After that, Julia's dispatch system finds the appropriate > specialization. > > Problem > The problem is that I don't know how safe it is to rely on the order of the > keyword arguments, as done here. > > Is there maybe an alternative solution to this problem that would still keep > the solution/naming succinct and easy to understand? > > (NOTE: this might be better suited for julia-dev, because it has to do with > the intended use of the keyword arguments) > > I hope someone out there has an answer, or a better solution to this problem. > > Regards, > > MA