Checked Array Access

This is the third post in the Sneak Preview series.

Much of the history of the ClojureScript compiler can be characterized by the themes of pragmatic expediency, followed by successive refinement. This is nicely illustrated by the history of aget.

The first minimum viable implementation of aget was a simple function. Six years ago it looked like this:

This employs the internal js* special form to directly emit JavaScript which uses subscript notation for element access. It looks roughly like this:

In the early history of the compiler, js* was employed fairly heavily in the runtime functions that ship with the ClojureScript standard library. Over time, raw usage of js* was removed entirely in the standard library and hidden behind reusable macros.

As time moved on, our friend aget (as well as aset) was refined to more closely match Clojure by allowing it to access nested array structures by using variadic arguments.

Readers familiar with JavaScript will note that the above aget implementation works perfectly well for JavaScript objects. This fact, like js*, was also abused in the early days of the standard library. Unfortunately, due to insufficient documentation about alternatives, users began to mimic this internal detail.

But aget was never designed to support this particular use. The “a-” family of functions (including aclone, amap, areduce) are all meant for arrays, not objects. The additional arguments to aget are numeric array indices, not string property names. Nevertheless, perhaps to the lure of ease, forms like

became heavily used in the wild to avoid the name mangling that comes with dotted property access and :advanced compilation. It was an accident of implementation that this worked at all, but nevertheless it became very popular.

One problem that this creates is a challenge in further evolving aget to match its intended purpose. A few examples that come to mind include:

What should you use for object property access, if aget and aset are reserved for arrays? ClojureScript makes the Google Closure library readily accessible, and there are some nice facilities worth checking out in the goog.object namespace. In particular, goog.object/get and goog.object/set are appropriate APIs, suited for this purpose. For example, this does what you’d want:

In fact, goog.object/get is safer in that it has checks that the object being passed is not nil and that the field being accessed actually exists on the object, allowing you to supply an alternative “not found” value to return if not. If you need to do nested property access, there is a goog.object/getValueByKeys that can also be considered as a drop-in replacement for a variadic aget call.

The ClojureScript standard library itself had places where aget and aset were being misused for object access, and these have been cleaned up. It turns out that goog.object/get is sufficiently performant to replace nearly all uses of aget for object access. In the relatively few places where it is not (in highly performance-critical areas in the standard library implmentation), the compiler makes use of a new internal unchecked-get macro to get the job done.

We’d encourage you to revise code you control to to ensure that the aget and aset are used only for array access, and to consider using the facilities in goog.object (either directly, or indirectly via a library such as cljs-oops) to access object properties.