convex.std — world.convex/cvm.clj 0.0.0-alpha4

Provides an API for cells with classic convex.core functions such as conj.

All clojure.core functions related to sequences usually understand Convex collections, making them easy to handle. Some of those (eg. cons, next) have counterparts in this namespace in case the return value must be a cell instead of a Clojure sequence.

Functions take and return cells unless specified otherwise. Predicates return JVM booleans.

Sometimes, it can be useful converting cells to Clojure data, such as unwrapping blob to byte arrays, which is the purpose of the convex.clj namespace.

Lastly, in the rare cases where all of this would not be enough, Java interop can be used:

https://www.javadoc.io/doc/world.convex/convex-core/latest/convex/core/data/package-summary.html

* clj

(* & xs)

Like classic * but for numeric cells.

+ clj

(+ & xs)

Like classic + but for numeric cells.

- clj

(- & xs)

Like classic - but for numeric cells.

< clj

(< & xs)

Like classic < but with numeric cells.

<= clj

(<= & xs)

Like classic <= but with numeric cells.

== clj

(== & xs)

Like classic == but with numeric cells.

> clj

(> & xs)

Like classic > but with numeric cells.

>= clj

(>= & xs)

Like classic >= but with numeric cells.

abs clj

(abs number)

Returns the absolute value of x.

Same type as x.

account-key clj

(account-key cell)

Coerces the given cell to an account key or return nil.

Works with:

• 64-char hex-string cell
• 32-byte blob

address clj

(address cell)

Coerces the given cell to an address or return nil.

Works with:

• Long cell
• 16-char hex-string cell
• 8-byte blob

address? clj

(address? x)

Is x an address?

assoc clj

(assoc coll k v)

Like classic assoc but for collection cells.

blob clj

(blob cell)

Coerces the given cell to a blob or return nil.

Works with:

• Any kind of blob (eg. hash)
• Long cell
• Hex-string cell

blob-map clj

(blob-map & kvs)

Builds a blob map from key-values (keys must be blobs).

blob-map? clj

(blob-map? x)

Is x a blob map?

blob? clj

(blob? x)

Is x a blob?

boolean? clj

(boolean? x)

Is x a CVM boolean?

byte clj

(byte cell)

Coerces the given cell to a byte or return nil.

byte? clj

(byte? x)

Is x a byte cell?

ceil clj

(ceil number)

Returns a double cell ceiling the value of number.

cell? clj

(cell? x)

Is x a cell?

char clj

(char cell)

Coerces the given cell to a char or return nil.

char? clj

(char? x)

Is x a char cell?

coll? clj

(coll? x)

Is x a collection cell?

concat clj

(concat x y)

Like classic concat but for collection cells.

Return type is the same as x.

conj clj

(conj)

(conj coll)

(conj coll v)

Akin to classic conj but for collection cells.

cons clj

(cons x coll)

Like classic cons but for collection cells.

Returns a list cell.

contains? clj

(contains? coll k)

Like classic contains? but for collection cells.

count clj

(count countable)

Returns a JVM long representing the number of itms in the given cell.

A countable is either:

• Blob
• Blob map
• Map
• List
• Set
• String
• Vector

cvm-value? clj

(cvm-value? x)

Is x a CVM value?

Returns false if x is not accessible to the CVM and meant to be used outside (eg. networking).

dec clj

(dec long)

Like classic dec but for long cells.

difference clj

(difference set-1 set-2)

Like clojure.set/difference but for set cells.

dissoc clj

(dissoc map k)

Like classic dissoc but for map cells.

div clj

(div & xs)

Like classic / but for numeric cells.

double clj

(double cell)

Coerces the given cell to a double or return nil.

double? clj

(double? x)

Is x a double cell?

empty clj

(empty coll)

Like classic empty but for collection cells.

empty? clj

(empty? countable)

Is the given countable empty?

See count.

exp clj

(exp number)

Returns e raised to the power of the given numeric cell.

false? clj

(false? x)

Is x a false cell?

find clj

(find map k)

Like classic `find`` but for map cells.

floor clj

(floor x)

Returns a double cell flooring the value of x.

get clj

(get coll k)

(get coll k not-found)

Like classic get but for collection cells.

hash-map clj

(hash-map & kvs)

Builds a map from key-values.

hash-map? clj

(hash-map? x)

Is x a hash map cell?

hash-set clj

(hash-set & cell+)

Builds a set from the given cells.

hash-set? clj

(hash-set? x)

Is x a hash set cell?

Currently at least, hast sets are the only kind of available sets.

inc clj

(inc long)

Like classic inc but for long cells.

intersection clj

(intersection set-1 set-2)

Like clojure.set/intersection but for set cells.

into clj

(into to from)

(into to xform from)

Like classic into but to is a collection cell.

keys clj

(keys map)

Like classic keys but for map cells.

Returns an eager vector cell.

keyword clj

(keyword cell)

Coerces the given cell to a keyword or return nil.

Works with:

• Max 64-char string cell
• Symbol

keyword? clj

(keyword? x)

Is x a keyword cell?

list clj

(list & cell+)

Buildsa list from the given cells.

list? clj

(list? x)

Is x a list cell?

long clj

(long cell)

Coerces the given cell to a long or return nil.

long? clj

(long? x)

Is x a long cell?

map? clj

(map? x)

Is x a map cell?

merge clj

(merge map-1 map-2)

Like classic merge but for hash map cells (not blob maps).

mod clj

(mod a b)

Returns the integer modulus of a numerator divided by a divisor.

Result will always be positive and consistent with Euclidean Divsion.

name clj

(name symbolic)

Like classic name but for keyword and symbol cells.

Returns a string cell.

nan? clj

(nan? cell)

Is the given cell NaN?

next clj

(next coll)

Like classic next but for collection cells.

Return type is a list cell if coll is a list, a vector cell otherwise.

nth clj

(nth countable index)

Like classic nth but for countables.

Index must be a JVM long.

See count.

number? clj

(number? x)

Is x a numeric cell?

Either a long or a double.

pow clj

(pow x y)

Returns a CVM double, x raised to the power of y.

reverse clj

(reverse sq)

Like classic reverse but for sequential cells (list or vector cells).

set clj

(set cell)

Coerces the given cell to a set or return nil.

Works with any collection.

set? clj

(set? x)

Is x a set cell?

Currently at least, hast sets are the only kind of available sets.

signum clj

(signum number)

Returns the sign of the number:

• -1 if negative
• 0 if 0
• 1 if positive

As a long cell if input is a long, double cell if it is a double.

sqrt clj

(sqrt number)

Returns a double cell, the square root of the given number cell.

str clj

(str & cell+)

Stringifies the given cell(s).

string? clj

(string? x)

Is x a string cell?

subset? clj

(subset? set-1 set-2)

Like clojure.set/subset? but for set cells.

symbol clj

(symbol cell)

Coerces the given cell to a symbol or return nil.

Works with:

• Max 64-char string cell
• Symbol

symbol? clj

(symbol? x)

Is x a symbol cell?

syntax? clj

(syntax? x)

Is x a syntax cell?

true? clj

(true? x)

Is x a true cell?

union clj

(union set-1 set-2)

Like clojure.set/union but for set cells.

update clj

(update coll k f)

Akin to classic update but for collection cell.

vals clj

(vals map)

Like classic vals but for map cells.

Returns an eager vector cell.

vec clj

(vec cell)

Coerces the given cell to a vector or return nil.

Works with any countable (see count).

vector clj

(vector & cell+)

Builds a vector from the given cells.

vector? clj

(vector? x)

Is x a vector cell?

zero? clj

(zero? x)

Like classic zero? but for cells.