Pair Overview

The original Lisp was billed as a list processing language. It is one of the oldest computer languages in use today, and was one of the first to implement true Artificial Intelligence techniques. It is the strength of it's list processing features and functionality that makes Lisp the language of choice, in the United States, for such applications as parsing, semantic analysis, and natural language processing. Pairs and Lists together with all of the functions available to manipulate them greatly expand the analytic power of the Analytic Information Server programmer.

The most difficult aspect of Pairs and Lists is their simplest aspect. Pairs are things. Lists are not things. Lists are one way of chaining Pairs together. Lists are not even the only way of chaining Pairs together (albeit an important way but not the only way). Some similar examples from everyday experience would include rain and crowds. Water droplets are things. Rain is not a thing. It is a collection of falling water droplets. There are collections of water droplets that are not rain. Rain is only one way of configuring lots of water droplets. People are things. Crowds are not things. They are collections of people under certain circumstances. Crowds are not the only configuration of lots of people. There are other ways lots of people can be collected together, villages, cities, clubs, etc.

Pair Illustration

Pairs are very simple objects, which are divided two parts as follows:


Pair Image 001


The car is the first part of the Pair and the cdr is the last part of the Pair. Both the car and the cdr may contain the full range of Analytic Information Server values: native types, objects, Lambdas, etc. In fact, both the car and the cdr may point to other Pairs, which is how Lists are configured, but that will come later. Once again, Pairs are simple objects which contain two values: a car value and a cdr value.

A Pair can be represented in a constant form as follows:

'( A . B )

In the preceding example, A is the car and B is the cdr. Pairs do not have to contain the same type of values as follows:

'( 1 . "Hello" )

In the preceding example, the car contains the Integer value 1, and the cdr contains the Text value "Hello". Pairs may contain complex objects as follows:

'( #(1 2 3) . (1 . 2) )

In the preceding example, the car contains a reference to the Vector object #(1 2 3), and the cdr contains a reference to the Pair value '(1 . 2). Pairs may refer to other Pairs which may refer to other Pairs, ad infinitum., and that is how Lists can be constructed.

Visual Basic Comparison

The Pair and List constructs do not have a Visual Basic equivalent. Visual Basic is not suitable for List processing applications.

Object Data Types

The Pair is a Heap Object or an Object Data Type. The Analytic Information Server Object Types are stored in the Heap and are managed by the Heap manager. The Analytic Information Server Heap manager supports object resizing, garbage collection, and anti-fragmentation algorithms so that the user may concentrate on the analysis and modeling of data rather than on memory management. Without exception, all of the Object types are identified by an object id. The object id identifies a block of memory, managed by the Lambda Information Server memory manager, in which the Object's data is stored.

The Analytic Information Server Heap Object and Native Data types can be saved and loaded to and from persistent (disk file) storage at any time. Containers with immediate data are saved on disk in fixed length records equal to the size of the container. Containers with Heap object references are saved in fixed length records, which are automatically expanded to include the contents of the Heap object, and any objects referenced by the Heap object, etc. This feature is called Object Closure Management and is automatic with every Analytic Information Server container database save.

Analytic Information Server containers may be loaded from any database repository record at any time. If the data in the record is immediate, the database load fills the container with the immediate data. If the data in the record is an object closure, the database load fills the container with a Heap object reference, and all of the objects in the record are loaded back into the Heap with the same referential relationships they had when they were saved in the repository.


Data Type Functions

The Pair object can be demonstrated by the following functions.

addMethod append apply associate
car compareEQ compareGE compareGT
compareLE compareLT compareNE compare
comparison cons copy count
defmethod delete isAtom isEqual
isIdentical isInside isMember isObject
isPair isType length map
mapc methodsOf pair send
setCar setCdr sizeof type


Data Type Examples

The Pair object can be demonstrated by the following examples.

Example_Pair_addMethod_024 Example_Pair_append_011 Example_Pair_apply_009 Example_Pair_apply_010
Example_Pair_associate_001 Example_Pair_car_001 Example_Pair_compareEQ_019 Example_Pair_compareGE_019
Example_Pair_compareGT_019 Example_Pair_compareLE_019 Example_Pair_compareLT_019 Example_Pair_compareNE_019
Example_Pair_compare_019 Example_Pair_comparison_019 Example_Pair_cons_001 Example_Pair_copy_009
Example_Pair_count_006 Example_Pair_defmethod_021 Example_Pair_isAtom_010 Example_Pair_isEqual_018
Example_Pair_isIdentical_017 Example_Pair_isInside_009 Example_Pair_isMember_008 Example_Pair_isObject_014
Example_Pair_isPair_001 Example_Pair_isType_021 Example_Pair_length_014 Example_Pair_map_008
Example_Pair_mapc_008 Example_Pair_methodsOf_021 Example_Pair_pair_001 Example_Pair_send_019
Example_Pair_setCar_001 Example_Pair_sizeof_021 Example_Pair_type_023