Pick fn arity independent of written order

[GreshamDanielStephens]

In pure clojure the fn arity chosen seems to be

1. The matching non-variadic fn first
2. Otherwise the matching variadic fn

((fn ([x & xs] "variadic") ([x] "otherwise")) 1)
=> "otherwise"
((fn ([x] "otherwise") ([x & xs] "variadic")) 1)
=> "otherwise"

Whereas in sci, the choice is based on the order that the arities are written in

((fn ([x & xs] "variadic") ([x] "otherwise")) 1)
=> "variadic"
((fn ([x] "otherwise") ([x & xs] "variadic")) 1)
=> "otherwise"

This fixes the issue by actively ordering the different fn arities to choose variadic arities last, thereby preferring exact matches.

[borkdude]

@GreshamDanielStephens Thanks. I agree with the issue, but your implementation will sort on every function invocation, which can be improved by moving the sort outside of the function body.

Potentially we can improve things even more by making a map of fixed-arity -> fn for the fixed arities and invoking the varargs body if it can't be found.

[GreshamDanielStephens]

ahh very true, I'll take a look, thanks for the feedback.

[GreshamDanielStephens]

updated with the map for fixed arities, and falling back on checking if the variadic-fn is viable.
I've force pushed since it's a small change and not much of the original remains, I hope that's okay.

[borkdude]

@GreshamDanielStephens Can we maybe collapse all of this processing into one reduce for more performance?

(let [by-arity (reduce (fn [acc body] (assoc acc ...)) fn-bodies)

We can reserve a special key for the var-args body or return a tuple from the reduce.

[GreshamDanielStephens]

Reworked it a bit and I think it's looking better now, hope that's what you had in mind!

[borkdude]

@GreshamDanielStephens I did some perf measurements on master and this branch:

$ clj -J-Dclojure.compiler.direct-linking=true

user=> (time (sci/eval-string "(defn foo ([a b] b) ([a] a) ([a b c d] d)) (dotimes [i 10000000] (foo 1 2 3 4))"))

"Elapsed time: 9074.377857 msecs"

user=> (time (sci/eval-string "(defn foo ([a b] b) ([a] a) ([a b c d] d)) (dotimes [i 10000000] (foo 1 2 3 4))"))
"Elapsed time: 6403.763242 msecs"

So that seems to be nice speed up.