sweet-array.core — dev.athos/sweet-array 0.3.0

aclone clj macro

(aclone arr)

aclone* clj macro

(aclone* arr)

aget clj macro

(aget arr idx & more)

Works just like clojure.core/aget, but with static checking of the array type to detect type errors at compile time.

aget* clj macro

(aget* arr idx & more)

array-class-syntax-supported? clj

array-type? clj

(array-type? t)

Returns true if and only if the given type is an array type.

array? clj

(array? x)

Returns true if and only if the given object is an array.

aset clj macro

(aset arr idx & idxv)

Works just like clojure.core/aset, but with static checking of the array type to detect type errors at compile time.

aset* clj macro

(aset* arr idx & idxv)

cast clj macro

(cast type-desc expr)

Casts the given expression expr to the array type denoted by type-desc.

This macro only has the compile-time effect and does nothing at runtime.

def clj macro

(def name arr)

(def name docstr arr)

The macro version of def dedicated to arrays. This macro can be used as a drop-in replacement for Clojure's def. Unlike the ordinary def form, (sweet-array.core/def <var> <init>) infers the static type of <init> and implicitly adds the inferred type as the type hint for <var>. Throws an error at macro expansion time if the type of <init> cannot be statically inferred or if the inferred type is not an array type.

def* clj macro

(def* name sym docstr expr)

install-array-literals! clj

(install-array-literals!)

Experimental - Enables array literals globally.

This function is intended for use in user.clj or other initialization code to enable array literals. Note: This function has no effect when used from the REPL. Use use-array-literals! to enable array literals interactively in the REPL.

instance? clj macro

(instance? type-desc x)

Evaluates x and tests if it is an instance of the array type denoted by type-desc.

into-array clj macro

(into-array type-desc coll)

(into-array type-desc xform coll)

Converts the given collection (seqable) to an array of the type denoted by type-desc. A transducer may be supplied.

new clj macro

(new type-desc & args)

Creates an array of the type denoted by type-desc.

The macro has two forms:

• (new [T] n): produce an array of type T of size n
• (new [T] [e_1 ... e_n]): produce an array of type T of size n initialized with elements e_1, ..., e_n.

tag clj macro

(tag desc)

tag-fn clj

(tag-fn type-desc)

type clj macro

(type desc)

Returns the class object that represents the array type denoted by type-desc.

type-fn clj

(type-fn desc)

use-array-literals! clj

(use-array-literals!)

Experimental - Enables array literals for the current REPL session.

Use this function when working in the REPL. Note: This function will throw an error if used in user.clj. If you need to enable array literals for code written in files, use install-array-literals! instead.