List space
The Nodes are relatively high-level structures and at runtime within the peer-nodes they sit upon a more fundamental layer called List-Space in which the actual nodal change takes place in a peer.
The project uses a very fundamental memory model based on binary sequences where each bit in the sequence can be referred to also by a key which is a binary-sequence of fixed length (determined by the total number of bits in the sequence). This can be done because binary-sequences can represent numbers as well as arbitrary content.
There is no arbitrary content in the List-Space though, the only actual content stored in this binary memory are List-Items, which are each a sequence of three binary List-Item-Keys. Since the smallest addressable unit in the List-Space is the List-Item, the size of a List-Item-Key can be based on the total number of List-Items that can fit in the space, rather than the total number of bits. For simplicity and efficiency of running in current environments, ensuring the List-Item size is on DWORD boundaries may be best. Maybe 32-bit List-Item-Keys, or maybe 64-bit List-Items with 21-bit keys.
The middle key is called the data-key and its meaning and use are context-specific. The first and last keys in a List-Item are the previous-key (prev) and next-key (next) allowing the formation of doubly-linked lists called Lists, and hence List-Space. (List-Item 0 is the Root-List-Item and Root-Node and indicates a null link). Lists are referred to by the List-Item-Key of their first List-Item and such keys a referred to as List-Keys. List-Keys are a subset of the List-Item-Keys.
- List Space Methods
List Space is an environment which offers a generic set of methods which can manipulate a space of generic List-Items each addressable by a binary List-Item-Key. Each List-Item is composed of three List-Item-Keys. This simple model is rich enough to support many kinds of higher data structures such as stacks, queues, threads, loops and trees.
- listInsert()
- listRemove(subject)
- listTraverse(subject, object)
- listGetValue(subject)
- listSetValue(subject, value)
- listGetKeys(subject)
- List Characteristics
There are a number of ways that list-items can be linked together to form lists which gives rise to some important list-characteristics. List Space itself has no concept of kinds of list, or a lists characteristics, so this is really a summary of the way the lists can be used by higher levels such as Node Space. More exotic structures such as binary-trees can also be constructed from list-items if the prev-keys aren't forced to link back to the item linking to them with its next-key.
The Node Space only uses one list space structrue which is the Loop. Other kinds of list configurations possible with List Space are stacks, queues, axes. Lists can also have the equivalient of names.
