Welcome to the Dictionary of Programming Languages, a compendium of computer coding methods assembled to provide information and aid your appreciation for computer science history.

Browse the dictionary by clicking on a section:
       A  B  C  D  E  F  G  H  I  JK  L  M  N  O  P  QR  S  T  UV  WXYZ+ 

Get a full dump of the dictionary:
       List of Names      Short Form      Full Form

Leda

Language type:

O - Object-oriented

Description:

Leda is a modest-sized programming language designed to support several programming approaches. The current Leda implementations are interpreters, but the language can be compiled. Leda was intended mostly as a teaching and research tool, although it can be used for general application development.
Multiparadigm programming is the reason for Leda's existence; the language supports four programming mindsets:
1. Imperative (structured) - the programmer can set up subroutines, use strong type checking, and information hiding.
2. Object-oriented - abstract data types, classes, and single inheritance are supported.
3. Functional - functions are first-class values, and Leda can do currying and other functional operations
4. Logical - Definition of logical rules is supported, with conventional backtracking goal search.

A fairly small language, Leda supports a modest but eclectic set of primitive data types: integers, strings, reals, functions, and relations (rules). Arrays are also available, and other aggregate data types are provided by a standard library. Leda supports the usual sequential control structures, and more novel structures can be built up using the functional and logical portions of the language. Strangely, Leda does not possess any non-local exception or error handling facility.
Leda's I/O facilities are rudimentary, although the language provides an escape mechanism out to system libraries that could be used to take advantage of more sophisticated I/O facilities on many operating systems.
An implementation of Leda is available free for Unix and Windows 95/NT. Pretty good information about the language is available on the web as scholarly papers and chapters from a programming textbook.

Origin:

T.A. Budd, Oregon State University, 1988.

See Also:

C++    Pascal    Self    ML    Prolog    Scheme    Mathematica   

Remarks:

According to the introductory chapter of the Leda text, the language is meant to allow a programmer to employ multiple ways of approaching a problem. Some computational tasks are more naturally expressed in certain ways, and choice of language tends to drive a programmer toward using the paradigm best supported by that language. Leda, and a scant handful of other languages, make a broader range of choices available to the user.
In its current form, Leda does not seem quite suited to mainstream application development, but it presents very interesting ideas.
The current Leda implementation is written in C.

Links:

An information page about Leda

Portions of a programming book about Leda

Date:

Last updated 3/1/98

Sample code:

{ Table data structure, adapted from an example
  in "Multiparadigm Data Structures in Leda"
  by Tim Budd, 1993

  Assumes the list data structure is already defined. }

class Association [X, Y : equality] of equality[Association];
var
	key : X;
	value : Y;
	function equals(argValue : Association[X, Y])->boolean;
	begin
		return key = argValue.key;
	end;
end;

class Table [X, Y : equality] { of equality[Association] };
var
	data : List[Association[X, Y]];

	function add (newKey : X, newValue : Y);
	begin
		if ~ defined(data) then
			data := List[Association[X, Y]]();
		data.add(Association[X, Y](newKey, newValue));
	end;

	function onEach (theFun : function(X, Y));
	begin
		if defined(data) then
			data.onEach(function (item : Association[X, Y]);
				begin
					theFun(item.key, item.value);
				end);
	end;

	function items (byRef key : X, byRef value : Y)->relation;
	var
		element : Association[X, Y];
	begin
		return defined(data) 
			& data.items(element)
			& unify[X](key, element.key)
			& unify[Y](value, element.value);
	end;

	function includesKey (key : X)->boolean;
	var
		value : Y;
	begin
		if items(key, value) then
			return true;
		return false;
	end;

	function at (key : X)->Y;
	var
		value : Y;
	begin
		if items(key, value) then
			return value;
		return NIL;
	end;

	function atPut (key : X, value : Y);
	var
		element : Association[X, Y];
	begin
		if defined(data) & data.items(element) & element.key = key then
			element.value := value
		else
			add(key, value);
	end;
end;

Descriptions in this dictionary are ©1997-99 Neal Ziring. Some examples copyright of their respective authors. Some technologies and languages are trademarked. Permission to copy descriptions is granted as long as authorship credit is preserved.

Comments on this dictionary, corrections and suggestions, are all welcome. Please use email, the address is ziring@home.com