T (programming language)

From Wikipedia, the free encyclopedia
Jump to: navigation, search
T
Paradigm multi-paradigm: object-oriented, imperative, functional, meta
Designed by Jonathan A. Rees and
Norman I. Adams
Developer Jonathan A. Rees and
Norman I. Adams
First appeared 1980s
Stable release 3.0 (August 1, 1984 (1984-08-01))
Typing discipline dynamic, strong
OS Cross-platform
Influenced by
Scheme
Influenced
EuLisp Joule

The T programming language is a dialect of the Scheme programming language developed in the early 1980s by Jonathan A. Rees, Kent M. Pitman, and Norman I. Adams of Yale University as an experiment in language design and implementation.

T's purpose is to test the thesis developed by Steele and Sussman in their series of papers about Scheme: that Scheme may be used as the basis for a practical programming language of exceptional expressive power, and that implementations of Scheme could perform better than other Lisp systems, and competitively with implementations of programming languages, such as C and BLISS, which are usually considered to be inherently more efficient than Lisp on conventional machine architectures.

In 1987 Stephen Slade published the book "The T Programming Language: A Dialect of LISP".

T contains some features that modern Scheme does not have. For example, T is object-oriented, and it has first-class environments, called locales, which can be modified non-locally and used as a module system. T has several extra special forms for lazy evaluation and flow control, as well as an equivalent to Common Lisp's setf. T, like Scheme, supports call-with-current-continuation, but it also has a more limited form called catch. From the T manual, a hypothetical implementation of cons could be:

 (define-predicate pair?)
 (define-settable-operation (car pair))
 (define-settable-operation (cdr pair))
 (define (cons the-car the-cdr)
         (object nil
                 ((pair? self) t)
                 ((car self) the-car)
                 ((cdr self) the-cdr)
                 (((setter car) self new-car) (set the-car new-car))
                 (((setter cdr) self new-cdr) (set the-cdr new-cdr))))

Through this example, we can see that objects in T are intimately related to closures and message-passing. A primitive called join puts two objects together, allowing for something resembling inheritance.

External links[edit]


Timeline of Lisp dialects(edit)
1955 1960 1965 1970 1975 1980 1985 1990 1995 2000 2005 2010 2015
Lisp 1.5 Lisp 1.5
Maclisp Maclisp
Interlisp Interlisp
ZetaLisp Lisp Machine Lisp
Scheme Scheme
NIL NIL
Common Lisp Common Lisp
T T
Emacs Lisp Emacs Lisp
AutoLISP AutoLISP
ISLISP ISLISP
EuLisp EuLisp
Racket Racket
Arc Arc
Clojure Clojure
LFE LFE
Hy Hy