> <\body> In this chapter, we give a rough description of 's basic data types in . The description of the exported functions is non exhaustive and we refer to the corresponding header files for more precision. The file declares the memory allocation routines. These routines are very fast for small sizes, since for each such size, maintains a linked list of freed objects of that size. No garbage collection has been implemented yet. Modulo a few exceptions, all composite data structures are based on the modules , , and . Consequently, these data structures are pointers to representation classes, which may be abstract in the case of and , and which always contain a reference counter. Because of the reference counter, the C++ copy operator is very fast. Most of the implemented data structures also export a function , which should be used if one really wants to physically duplicate an object, For classes constructed using or , the pointer to the representation class is allowed to be and we have a default constructor which initializes this pointer with . Instances of these classes are tested to be using the function . Examples of such classes are lists, files and widgets. implements three \Parray-like\Q structures: <\itemize> is the string type, which may contain '0' characters. is the tree type with string labels. T\> is the generic array type with elements of type . Array-like structures export the following operations: <\itemize> computes the length of an array. accesses an element. \> is used for appending elements or arrays. For trees , we notice that label> yields the label of the tree and a> the array of its children. The second argument of \> for trees is either a tree or an array of trees. The implementation has been made such that the \> operation is fast, which is useful when considering arrays as buffers. Actually, the allocated space for arrays with more than five elements (words for strings) is always a power of two, so that new elements can be appended quickly. Notice that GNU malloc also always allocates blocks, whose sizes are powers of two. Therefore, we do not waste memory for small and large arrays. Generic lists are implemented by the class T\>. The \Pnil\Q list is created using T\()>, an atom using T\(T x)> and a general list using T\(T x, list\T\ next)>. If is a list, item> and next> correspond to its label and its successor respectively ( and in lisp). The functions and tests whether a list is nil or an atom. The function computes the length of a list. The type T\> is also denoted by , because some additional functions are defined for it. Indeed, paths are used for accessing descendants in tree like structures. For instance, we implemented the function . The T,U\> class implements hash tables with entries in and values in . A function should be implemented for . Given a hash table . We set elements through\ <\verbatim> \ \ \ \ H(x)=y; and access to elements through\ <\verbatim> \ \ \ \ H[x] We also implemented a variant T,U\> of hash tables, which also have a list-like structure, which makes them useful for implementing recursive environments. <\itemize> implements abstract commands. implements files. T\> implements generic iterators. implements rectangles and lists of rectangles. implements stretchable spaces. implements timers. >