Uses of Interface
convex.core.data.IWriteable

Packages that use IWriteable

Package	Description
convex.core	Fundamental Convex classes used for the decentralised network
convex.core.crypto	Crypto algorithms used within Convex, particularly for digital signatures and cryptographic hashes
convex.core.data	Data structures and algorithms, including a complete set of classes required to implement immutable, decentralised data objects.
convex.core.data.impl
convex.core.data.prim	Implementation of CVM Primitive Data types
convex.core.lang	Core CVM implementation
convex.core.lang.impl	Internal CVM language implementation classes
convex.core.lang.ops	CVM Operations, effectively the "machine code" of the CVM
convex.core.transactions	Convex network transaction types.

Uses of IWriteable in convex.core

Classes in convex.core that implement IWriteable

Modifier and Type	Class	Description
class	Belief	Class representing a Peer's view of the overall network consensus state.
final class	Block	A Block contains an ordered collection of signed transactions that may be applied collectively as part of a state update.
class	BlockResult	Class representing the result of applying a Block to a State.
class	Order	Class representing an Ordering of transactions, along with the consensus position.
class	Receipt	Transaction Receipt record.
final class	Result	Class representing the result of a Query or Transaction.
class	State	Class representing the immutable state of the CVM State transitions are represented by blocks of transactions, according to the logic: s[n+1] = s[n].applyBlock(b[n]) State contains the following elements - Map of AccountStatus for every Address - Map of PeerStatus for every Peer Address - Global values - Schedule data structure "State.

Uses of IWriteable in convex.core.crypto

Classes in convex.core.crypto that implement IWriteable

Modifier and Type	Class	Description
class	ASignature	Class representing a cryptographic signature
class	Ed25519Signature	Immutable data value class representing an Ed25519 digital signature.

Uses of IWriteable in convex.core.data

Classes in convex.core.data that implement IWriteable

Modifier and Type	Class	Description
class	AArrayBlob	Abstract base class for binary data stored in Java arrays.
class	ABlob	Abstract base class for data objects containing immutable chunks of binary data.
class	ABlobLike<T extends ACell>	Abstract base class for Blob-like objects, which conceptually behave as a sequence of bytes.
class	AccountKey	Immutable class representing an Ed25519 Public Key for an Account
class	AccountStatus	Class representing the current on-chain status of an account.
class	ACell	Abstract base class for Cells.
class	ACollection<T extends ACell>	Abstract base class for Persistent Merkle Collections
class	ACountable<E extends ACell>	Abstract base class for Countable objects, supporting `count`, `nth`, `empty?` and `slice` Countable values support a count of elements and the ability to get by an element index.
class	ADataStructure<E extends ACell>	Abstract base class for Persistent data structures.
final class	Address	Immutable class representing an Address, generally used to uniquely identify an Account.
class	ADerivedBlob	Abstract Blob base base for Blobs that derive their functionality from other sources.
class	AHashMap<K extends ACell,V extends ACell>
class	AHashSet<T extends ACell>
class	AIndex<K extends ABlobLike<?>,V extends ACell>	Abstract base class for Indexes: a sorted radix-tree map of Blobs to Values.
class	AList<T extends ACell>	Abstract base class for lists.
class	ALongBlob
class	AMap<K extends ACell,V extends ACell>	Abstract base class for maps.
class	AMapEntry<K extends ACell,V extends ACell>
class	ARecord	Base class for Record data types.
class	ARecordGeneric	Abstract base class for generic records.
class	ASequence<T extends ACell>	Abstract base class for concrete sequential data structure (immutable persistent lists and vectors etc.)
class	ASet<T extends ACell>	Abstract based class for sets.
class	ASpecialVector<T extends ACell>	BAse class for specialised vector implementations
class	AString	Abstract base Class representing a CVM String.
class	ASymbolic	Abstract based class for symbolic objects (Keywords, Symbols)
class	AVector<T extends ACell>	Abstract base class for vectors.
class	Blob	General purpose immutable wrapper for byte array data.
class	BlobTree	Implementation of a large Blob data structure consisting of 2 or more chunks.
class	Hash	Class used to represent an immutable 32-byte Hash value.
final class	Index<K extends ABlobLike<?>,V extends ACell>	Index node implementation, providing an efficient radix tree based immutable data structure for indexed access and sorting.
final class	Keyword	Keyword data type.
class	List<T extends ACell>	Implementation of a list wrapping a vector.
final class	LongBlob	Wrapper for an 8-byte long as a Blob We use this mainly for efficient management of indexes using Longs in Indexes.
class	MapEntry<K extends ACell,V extends ACell>	Map.Entry implementation for persistent maps.
class	MapLeaf<K extends ACell,V extends ACell>	Limited size Persistent Merkle Map implemented as a small sorted list of Key/Value pairs Must be sorted by Key hash value to ensure uniqueness of representation
class	MapTree<K extends ACell,V extends ACell>	Persistent Map for large hash maps requiring tree structure.
class	PeerStatus	Class describing the on-chain state of a Peer declared on the network.
class	Ref<T extends ACell>	Class representing a smart reference to a decentralised data value.
class	RefDirect<T extends ACell>	Ref subclass for direct in-memory references.
class	RefSoft<T extends ACell>	Reference class implemented via a soft reference and store lookup.
class	SetLeaf<T extends ACell>	Limited size Persistent Merkle Set implemented as a small sorted list of Values Must be sorted by Key hash value to ensure uniqueness of representation
class	SetTree<T extends ACell>	Persistent Set for large hash sets requiring tree structure.
final class	SignedData<T extends ACell>	Node representing a signed data object.
final class	StringShort	Class representing a short CVM string, backed by a flat Blob Used for most small strings, and acts as the leaf chunk for StringTrees
class	StringSlice	AString subclass representing a view some String data.
class	StringTree	String implementation class wrapping a BlobTree.
final class	Symbol	Class representing a Symbol.
final class	Syntax	Class representing a Syntax Object.
class	VectorArray<T extends ACell>	Non-canonical vector implementation designed to make operations on small temporary vectors more efficient.
class	VectorLeaf<T extends ACell>	A Persistent Vector implementation representing 0-16 elements with a packed Vector prefix.
class	VectorTree<T extends ACell>	Persistent Vector implemented as a merkle tree of chunks shift indicates the level of the tree: 4 = 1st level, 8 = second etc.

Uses of IWriteable in convex.core.data.impl

Classes in convex.core.data.impl that implement IWriteable

Modifier and Type	Class	Description
class	ADerivedSet<T extends ACell,K extends ACell,V extends ACell>	Abstract base class for non-canonical sets derived off maps Useful for cases where we want a Set instance, but don't want to construct a whole new data structure
class	KeySet<K extends ACell,V extends ACell>
class	ZeroBlob	Blob filled with all zeros.

Uses of IWriteable in convex.core.data.prim

Classes in convex.core.data.prim that implement IWriteable

Modifier and Type	Class	Description
class	AInteger	Abstract base class for CVM Integer values
class	ANumeric	BAse class for CVM numeric types
class	APrimitive	Abstract base class for CVM primitive values.
final class	CVMBigInteger	Arbitrary precision Integer implementation for the CVM.
final class	CVMBool	Class for CVM Boolean types.
final class	CVMChar	Class for CVM Character values.
final class	CVMDouble	Class for CVM double floating-point values.
final class	CVMLong	Class for CVM long values.

Uses of IWriteable in convex.core.lang

Classes in convex.core.lang that implement IWriteable

Modifier and Type	Class	Description
class	AFn<T extends ACell>	Base class for functions expressed as values "You know what's web-scale? The Web.
class	AOp<T extends ACell>	Abstract base class for CVM operations "...that was the big revelation to me when I was in graduate school—when I finally understood that the half page of code on the bottom of page 13 of the Lisp 1.5 manual was Lisp in itself.

Uses of IWriteable in convex.core.lang.impl

Classes in convex.core.lang.impl that implement IWriteable

Modifier and Type	Class	Description
class	AClosure<T extends ACell>	Abstract base class for functions that can close over a lexical environment.
class	ADataFn<T extends ACell>	Abstract base class for data structure lookup functions.
class	CoreFn<T extends ACell>	Abstract base class for core language functions implemented in the Runtime Core functions are tagged using their symbols in on-chain representation
class	CorePred	Abstract base class for core predicate functions
class	Fn<T extends ACell>	Value class representing a instantiated closure / lambda function.
class	KeywordFn<T extends ACell>
class	MapFn<K extends ACell,T extends ACell>
class	MultiFn<T extends ACell>
class	SeqFn<T extends ACell>	Wrapper for interpreting a sequence object as an invokable function
class	SetFn<T extends ACell>

Uses of IWriteable in convex.core.lang.ops

Classes in convex.core.lang.ops that implement IWriteable

Modifier and Type	Class	Description
class	AMultiOp<T extends ACell>	Abstract base class for Ops with multiple nested operations MultiOps may selectively evaluate sub-expressions.
class	Cond<T extends ACell>	Op representing a conditional expression.
class	Constant<T extends ACell>	Operation representing a constant value "One man's constant is another man's variable." - Alan Perlis
class	Def<T extends ACell>	Op that creates a definition in the current environment.
class	Do<T extends ACell>	Op for executing a sequence of child operations in order "Design is to take things apart in such a way that they can be put back together" - Rich Hickey
class	Invoke<T extends ACell>	Op representing the invocation of a function.
class	Lambda<T extends ACell>	Op responsible for creating a new function (closure).
class	Let<T extends ACell>	Op for executing a body after lexically binding one or more symbols.
class	Local<T extends ACell>	Op to look up a local value from the lexical environment
class	Lookup<T extends ACell>	Op to look up a Symbol in the current execution context.
class	Query<T extends ACell>	Op for executing a sequence of child operations in order in query mode (no state changes) "Design is to take things apart in such a way that they can be put back together" - Rich Hickey
class	Set<T extends ACell>	Op to set a lexical value in the local execution context.
class	Special<T extends ACell>	Op representing special Symbols like *address* and *caller*

Uses of IWriteable in convex.core.transactions

Classes in convex.core.transactions that implement IWriteable

Modifier and Type	Class	Description
class	ATransaction	Abstract base class for immutable transactions Transactions may modify the on-chain State according to the rules of the specific transaction type.
class	Call	Transaction representing a Call to an Actor.
class	Invoke	Transaction class representing the Invoke of an on-chain operation.
class	Multi	The Multi class enables multiple child transactions to be grouped into a single wrapper transaction with useful joint execution semantics.
class	Transfer	Transaction class representing a coin Transfer from one account to another