Type | Location | Extends | Description |
---|---|---|---|
array_list | array_list_mod | list | A concrete implementation of the list abstract data type. This implementation stores list contents in an array. It is fast to read from, but it is slow to insert elements into the middle of the list or to add new items to the end (if doing so requires the storage array to be expanded). |
bidir_node | bidir_node_mod | linked_node | A node which, in addition to holding a value, points at two other (the previous and next) bidir_node objects or objects of a descendent type. This type can be built up into a chain, allowing a doubly-linked list to be formed. |
character_container | container_mod | container | A container for holding the defualt character type. |
complex16_container | container_mod | container | A container for holding the 16 byte complex type. |
complex4_container | container_mod | container | A container for holding the 4 byte complex type. |
complex8_container | container_mod | container | A container for holding the 8 byte complex type. |
complex_container | container_mod | container | A container for holding the defualt complex type. |
container | abstract_container_mod | None | An abstract derived type which contains data. This type can be
used for a sort of unlimited polymorphism. It is extended to
create different classes capable of holding particular
data-types. Extensions must implement the procedure
typeguard in order to provide the ability to
transfer data out of the container and into a variable. Assuming
that you are creating a concrete class called
|
countable | countable_mod | iterable | An abstract data type which can be iterated, for which the number of pieces of items of data stored within is known. |
data_set | data_set_mod | countable | An abstract type for set data structures. These sets support a similar selection of operations as do their mathematical counterparts. The collection of methods for this type waas inspired by those available for the frozenset type in Python. |
deque | deque_mod | queue | An abstract data type representing the double ended queue data structure. Rather than just pushing items to one end (the "left end") and popping them from the other (the "right end"), items can be pushed or popped to/from either the right or the left. |
dictionary | dictionary_mod | data_set | An abstract type for mapping data structures. These are data structures which consist of key-value pairs. Examples of such structures are dictionaries in Python or a hash variable in Perl. |
dynamic_set | dynamic_set_mod | data_set | An abstract data type for dynamic sets. These are much like mathematical sets, but differ from the parent data_set type in that items can be added to or removed from the set. To accomplish this, various additional methods are available. This data type is similar to the set type in Python. |
int1_container | container_mod | container | A container for holding the 1 byte integer type. |
int2_container | container_mod | container | A container for holding the 2 byte integer type. |
int4_container | container_mod | container | A container for holding the 4 byte integer type. |
int8_container | container_mod | container | A container for holding the 8 byte integer type. |
int_container | container_mod | container | A container for holding the defualt integer type. |
iterable | iterable_mod | None | An abstract type which can return and iterator object representing its contents. All of the more complex public data structures in FIAT are descendants of this one. |
iterator | iterator_mod | None | A data type which provides a collection of data to the user. Objects
of this type are returned using the iter method of
FIAT's other data types. The contents of the iterator are set to be
the same as the iterable at the time when the |
linked_node | linked_node_mod | node | A node which, in addition to holding a value, points at another (the next) linked_node or descendent type. This type can be built up into a chain, allowing a linked list to be formed. |
list | list_mod | deque | An abstract data type representing a list. This is a fully dynamic means of storing data of a single type and comes with many advanced type-bound procedures for manipulating said data. This derived type aims to provide many of the same features found in lists in higher-level languages such as Python |
logical_container | container_mod | container | A container for holding the defualt logical type. |
map | map_mod | dictionary | An abstract type for the standard map data structures. These are data structures which consist of key-value pairs, with only one value per key. It has similar functionality to the dictionary type in Python. |
multimap | multimap_mod | dictionary | An abstract type for the standard map data structures. These are data structures which consist of key-value pairs, potentially holding multiple values per key. |
multiset | multiset_mod | dynamic_set | Provides an abstract type for a multi-set data structure. These
behave like a normal set, except they keep count of the number of
times which an item has been added. When an item is removed, the
count will be decremented by 1. The item will only become absent
from the list (has returns |
node | node_mod | None | An object which contains a container that can be set to have arbitrary contents. While of limited use on its own, various derived types exist which are extensions of this one exist and are used to build more complex data structures. |
ordered | ordered_mod | countable | An abstract type which is an ancestor for any data structure in which items are stored in a particular order. This means that the order in which items are placed in the structure will determine the order in which they are retrieved. Examples of data structures descending from this one are a [[stack]], queue, or list. |
queue | queue_mod | ordered | An abstract data type representing the queue structure. This is largely a placeholder type, in case some methods specific to queues are added at a later time. However, it does implement the is_fifo method. |
real16_container | container_mod | container | A container for holding the 16 byte real type. |
real4_container | container_mod | container | A container for holding the 4 byte real type. |
real8_container | container_mod | container | A container for holding the 8 byte real type. |
real_container | container_mod | container | A container for holding the defualt real type. |