Q (equational programming language)

Q
Paradigm(s)	multiparadigm: functional, object-oriented
Appeared in	1991 (1991)
Designed by	Albert Gräf
Stable release	7.5 (September 12, 2006)
Typing discipline	dynamic, strong
Major implementations	Q
Influenced	Pure
q-lang.sourceforge.net

This article includes a list of references, related reading or external links, but its sources remain unclear because it lacks inline citations. Please improve this article by introducing more precise citations. (March 2011)

Q (short for equational programming language) is an interpreted, interactive functional programming language created by Albert Gräf at the University of Mainz in Germany. Q programs are just collections of equations which are used to evaluate expressions in a symbolic fashion. Q has many similarities with other modern functional programming languages like Haskell and ML, but is based on general term rewriting (a method of computation also used by the Mathematica computer algebra system) instead of the lambda calculus.

Despite its conceptual simplicity, Q is a full-featured functional programming language with a modern syntax, currying, dynamic typing using an object-oriented type system, exception handling, POSIX multithreading, a comprehensive standard library, and an interface to the C programming language. Q is an impure functional language (i.e., operations with side-effects are permitted) with a default eager evaluation strategy; "special forms" can be used to implement data structures and operations featuring lazy evaluation. Q has been ported to a variety of operating systems, including BeOS, FreeBSD, Linux, Mac OS X, Solaris and Microsoft Windows. The interpreter is free software distributed under the GNU General Public License.

Various add-on modules are provided for interfacing, e.g., to GNU Octave, OpenDX (IBM's scientific visualization software), Tcl/Tk and ODBC. A graph editor and library is also available. This turns the language into a practical tool for scientific and other advanced applications. Q also comes with an extensive system interface (though not as comprehensive as the facilities provided by other scripting languages such as Perl and Python). Moreover, computer music applications are supported via portable interfaces for MIDI and digital audio programming.

Q has been succeeded by Pure.

Examples

A "hello world" example:

hello            = writes "Hello, world!\n";

The following function generates the "stream" (a.k.a. infinite list) of all prime numbers:

primes           = sieve (ints 2);
ints N           = bin N (ints (N+1));
sieve (bin X Xs) = bin X (sieve (filter (ndivby X) Xs));
ndivby M N       = N mod M <> 0;

An algorithm to solve the "N queens" problem, using backtracking:

queens N         = search N 1 1 [];

search N I J P   = write P || writes "\n" if I>N;
                 = search N (I+1) 1 (P++[(I,J)]) || fail if safe (I,J) P;
                 = search N I (J+1) P if J<N;
                 = () otherwise;

safe (I1,J1) P   = not any (check (I1,J1)) P;

check (I1,J1) (I2,J2)
                 = (I1=I2) or else (J1=J2) or else
                   (I1+J1=I2+J2) or else (I1-J1=I2-J2);

A tiny system programming example (fetch a file from a WWW server over a socket):

/* make sure SIGPIPE (broken connection signal) is ignored */

def _            = trap SIG_IGN SIGPIPE;

/* fetch a file from an http server (port 80) */

http HOST NAME   = close FD || bstr REPLY
                     where FD:Int = socket AF_INET SOCK_STREAM 0,
                       _ = connect FD (HOST,80),
                       _ = send FD 0 (bytestr (sprintf "GET %s\r\n\r\n" NAME)),
                       REPLY = recv_loop FD (bytestr "");

/* read data in 64K chunks */

recv_loop FD S   = recv_loop FD (S++T) if #T>0
                     where T:ByteStr = recv FD MSG_WAITALL (64*1024);
                 = S otherwise;

↑Jump back a section