sicmutils.structure — net.littleredcomputer/sicmutils 0.12.0

compatible-shape clj

(compatible-shape s)

Return an object compatible for multiplication with the given one, with the slots filled with gensyms.

component clj

(component & indices)

Given an access chain (a sequence of indices), return a function of structures that will retrieve that corresponding element.

dimension clj

(dimension s)

down clj

(down & xs)

Construct a down (covariant) tuple from the arguments.

flip-indices clj

(flip-indices s)

Make a tuple with the same shape as s but all orientations inverted.

generate clj

(generate dimension orientation f)

Generate a structure with the given orientation whose elements are (f i) where i ranges from [0..dimension)

mapr clj

(mapr f & structures)

Return a structure with the same shape as s but with f applied to each primitive (that is, not structural) component.

opposite clj

(opposite s xs)

Make a tuple containing xs with the orientation opposite to s.

orientation clj

(orientation s)

Return the orientation of s, either ::up or ::down.

same clj

(same s xs)

Make a tuple containing xs with the same orientation as s.

structure->access-chains clj

(structure->access-chains s)

Return a structure of the same shape as s whose elements are access chains corresponding to position of each element (i.e., the sequence of indices needed to address that element).

structure->vector clj

(structure->vector s)

Return the structure in unoriented vector form.

structure-assoc-in clj

(structure-assoc-in s [k & ks] value)

Like assoc-in, but works for structures. At this writing we're not sure if we want to overwrite the stock definition of assoc-in to something that would fall through for standard clojure data types

structure? clj

(structure? s)

True if s is a structure.

unflatten clj

(unflatten values struct)

(unflatten constructor values struct)

Given a sequence of values and a model structure, unpack the values into a structure with the same shape as the model.

up clj

(up & xs)

Construct an up (contravariant) tuple from the arguments.

up? clj

(up? s)

True if s in an up structure.

vector->down clj

(vector->down v)

Form a down-tuple from a vector.

vector->up clj

(vector->up v)

Form an up-tuple from a vector.