Given an arbitrary container, return the fastest idx->value accessor possible. If the item is agetable, this just wraps aget. Else, unless otherwise instructed, it will wrap #(-nth item %).

Create a javascript set. These have superior performance when dealing with numeric data but they fail completely when dealing with clojure data such as persistent maps or keywords

Convert arbitrary data into a set appropriate for the data. For numeric types, javascript sets are fastest else use a clojure set.

Add an item to a list.

add a countable sequence of items to a list

Return something that you can safely call (aget item idx) and that will return data of the same datatype. For :int64 this may return BigNum objects.

Only reduce to an aget-able item of the datatypes match. This avoids throwing away js array wrappers that may do more checking and that can accurately advertise elemwise datatypes.

Return the js array data backing this container. The object returned may have a different elemwise-datatype than the container.

Return the typed array data backing this container. The object returned may have a different elemwise-datatype than the container.

Here for compat with jvm system. All of the datatype objects implement ICloneable so cljs.core/clone works fine.

Copy src container into dest container.

Return true of js arrays and anything implementing ICounted.

Get the dataytpe of this object.

Compatibility with jvm-version. All of the datatype objects implement ICounted so cljs.core/count works fine.

Get the datatype of the elements in the container.

elementwise map a function over a sequences. Returns a countable/indexable array of results.

Ensure the list has at least this much capacity without changing the number of inserted items

Ensure this object is indexable. If object is not indexable this calles (vec item)

Ensure that itme is a typed array. Only works for numeric datatypes.

Reindex the buffer via the given indexes returning a new buffer. Unlike the jvm version this most likely results in a new container.

Efficiently iterate through the data calling consum-fn and passing in an index for every item.

Returns consume-fn.

Return true for js arrays and anything implementing IIndexed.

Return true if this is a clojure integer range object.

Efficiently iterate through the data calling consume-fn on every item.

Returns consume-fn.

Coalesce a possibly nested set of data into a single container that implements the dtype list protocol.

Example:

cljs.user> (dtype/list-coalesce! [[2 3 4][5 6 7]] (dtype/make-list :float32))
#list[[:float32 6][2 3 4 5 6 7]

Return a packed container of data. Container implements count, nth, and meta, with-meta, and elemwise-datatype. Uses typed-arrays for most primitive types and generic js arrays for anything else. The container itself cannot check that the input matches the datatype so that form of checking is not available in the js version (unlike the jvm version).

Make a list. Lists implement the tech.v3.datatype.protocols/PListLike protocol - add!, add-all!, ensure-capacity!

Return true if this datatype is a numeric type. True for :int8, :uint8 -> :int64, :uint64, float32, float64.

Create a new reader of elemwise-datatype dtype. The returned reader correctly implements hash and equiv such that it is indistinguishable from a persistent vector created as (mapv idx->val-fn (range n-elems))

Create an ordered int32 buffer of the items in the set.

Perform set-intersection. Implemented for efficiently js sets and clojure sets.

Perform set-difference. Implemented for efficiently js sets and clojure sets.

Set a constant value starting at idx and continuing elem-count values.

Offset every member of the set by a constant returning a new set

Perform set-union. Implemented for efficiently js sets and clojure sets.

Create a predicate out of a set. For js sets, calls .has and for Clojure sets just returns the set object.

Create a not-in-set predicate. See docs for set-predicate

Set value on the item. data may be a scalar or a sequence or Indexable object in which case it will be copied into item starting at idx.

Returns item

Create a sub-buffer that in most cases shared the backing store data with the parent buffer

Create a copy of the data in the item from offset till len.