Two separate optimization can be done.

In places where {{boolean}} is used (the {{qualified-}} fns), we can instead use {{some?}} for a faster implementation:

(boolean (and (symbol? x) (namespace x) true))

can be converted to simply

(and (symbol? x) (some? (namespace x)))

Focusing on just V8 for now, for

(simple-benchmark [x 'a/b f #(qualified-symbol? x)] (f) 100000000)

and subtracting out the baseline cost for

(simple-benchmark [x 'a/b f (fn [] x)] (f) 100000000)

this yields a speedup of 1.74.

Since we know that we are dealing with keywords or symbols when applying {{namespace}}, we can furthermore use {{(.-ns x)}}.

Alone this gives a speedup of 2.21 and when combined with the previous optimization as

(and (symbol? x) (some? (.-ns x)))

we see a combined speedup approaching infinity (the operation effectively becomes free, taking the same time as the baseline).

Note that we could perhaps use predicate-induced type inference along with a new macro for {{namespace}} that emits {{.-ns}} instead, but CLJS-2866 currently hinges on looking at the test in an {{if}}, while expressions like the above cause optimized {{js*}} output with short-circuiting {{&&}}.

These optimizations would be good because these functions are often used in spec-based generative code testing where performance can be an issue.

We have test coverage for these functions in {{cljs.predicates-test}}.

For reference here is the JavaScript currently emitted for {{qualified-symbol?}}

function cljs$core$qualified_symbol_QMARK_(x) {

return cljs.core.boolean$(

(function() {

var and__8540__auto__ = x instanceof cljs.core.Symbol;

if (and__8540__auto__) {

var and__8540__auto____$1 = cljs.core.namespace(x);

if (cljs.core.truth_(and__8540__auto____$1)) {

return true;

} else {

return and__8540__auto____$1;

}

} else {

return and__8540__auto__;

}

})()

);

}

and here is what we get with the revisions

function cljs$user$qualified_symbol_QMARK_(x) {

return x instanceof cljs.core.Symbol && !(x.ns == null);

}

(The compactness of this revised implementation means that it might be further inlinable via Closure for more speedups for whole-program optimization.)