Maclisp: Lisp тiлiнiң бір саласы

Dialect of Lisp programming language

Maclisp (or MACLISP, sometimes styled MacLisp or MacLISP) is a programming language, a dialect of the language Lisp. It originated at the Massachusetts Institute of Technology's (MIT) Project MAC (from which it derived its prefix) in the late 1960s and was based on Lisp 1.5. Richard Greenblatt was the main developer of the original codebase for the PDP 6; Maclisp departs from Lisp 1.5 by using a value cell to access and store the dynamic values of variables; Lisp 1.5 used a linear search of an association list to determine a variable's value. The Maclisp variable evaluation is faster but has different variable semantics. Maclisp also employed reader macros to make more readable input and output, termed input/output (I/O). Instead of entering (QUOTE A), one could enter 'A to get the same s expression. Although both implementations put functions on the property list, Maclisp uses different syntax to define functions. Maclisp also has a load on demand feature. Maclisp began on Digital Equipment Corporation PDP 6 and PDP 10 computers running the Incompatible Timesharing System (ITS); later it was ported to all other PDP 10 operating systems, for example, Timesharing / Total Operating System, TOPS 10 and TOPS 20. The original implementation was in assembly language, but a later implementation on Multics used PL/I. Maclisp developed considerably in its lifetime. Major features were added which in other language systems would typically correspond to major release numbers. Maclisp was used to implement the Macsyma computer algebra system (CAS) or symbolic algebra program. Macsyma's development also drove several features in Maclisp. The SHRDLU blocks world program was written in Maclisp, and so the language was in widespread use in the artificial intelligence (AI) research community through the early 1980s. It was also used to implement other programming languages, such as Planner and Scheme. Multics Maclisp was used to implement the first Lisp based Emacs. Maclisp was an influential Lisp implementation, but is no longer maintained actively. It now runs on PDP 10 emulators and can be used for experimenting with early AI programs.

Maclisp began with a small, fixed number of data types: cons cell, atom (later termed symbol), integer, and floating point number. Later additions included: arrays, which were never first class data types; arbitrary precision integers (bignums); strings; and tuples. All objects (except inums) were implemented as pointers, and their data type was determined by the block of memory into which it pointed, with a special case for small numbers (inums). Programs could be interpreted or compiled. Compiled behavior was the same as interpreted except that local variables were lexical by default in compiled code, unless declared SPECIAL, and no error checking was done for inline operations such as CAR and CDR. The Ncomplr compiler (mid 1970s) introduced fast numeric support to Lisp languages, generating machine code (instructions) for arithmetic rather than calling interpretive routines which dispatched on data type. This made Lisp arithmetic comparable in speed to Fortran for scalar operations (though Fortran array and loop implementation remained much faster). The original version was limited by the 18 bit word memory address of the PDP 10, and considerable effort was expended in keeping the implementation lean and simple. Multics Maclisp had a far larger address space, but was costly to use. When the memory and processing power of the PDP 10 were exceeded, the Lisp Machine was invented: Lisp Machine Lisp is the direct descendant of Maclisp. Several other Lisp dialects were also in use, and the need to unify the community resulted in the modern Common Lisp language.

Maclisp was named for Project MAC, and is unrelated to Apple's Macintosh (Mac) computer, which it predates by decades or to John McCarthy. The various Lisp systems for the Macintosh have no particular similarity to Maclisp.