Pure (programming language)

Functional programming language

"Pure (language)" redirects here. For the linguistic notions, see Linguistic purism and Adamic language.

Pure

Using Pure with TeXmacs

Paradigm| Functional, declarative, term rewriting
Designed by| Albert Gräf
Developer| Albert Gräf
First appeared| 2008; 17 years ago (2008)
Stable release|

0.68 / 11 April 2018; 7 years ago (2018-04-11)

Typing discipline| strong, dynamic
OS| Cross-platform: FreeBSD, Linux, macOS, Windows
License| GNU Lesser General Public License
Website| agraef.github.io/pure-lang
Influenced by
Q, Haskell, Lisp, Alice, MATLAB

Pure, successor to the equational language Q, is a dynamically typed, functional programming language based on term rewriting. It has facilities for user-defined operator syntax, macros, arbitrary-precision arithmetic (multiple-precision numbers), and compiling to native code through the LLVM. Pure is free and open-source software distributed (mostly) under the GNU Lesser General Public License version 3 or later.

## Overview

[edit]

Pure comes with an interpreter and debugger, provides automatic memory management, has powerful functional and symbolic programming abilities, and interfaces to libraries in C (e.g., for numerics, low-level protocols, and other such tasks). At the same time, Pure is a small language designed from scratch; its interpreter is not large, and the library modules are written in Pure. The syntax of Pure resembles that of Miranda and Haskell, but it is a free-format language and thus uses explicit delimiters (rather than off-side rule indents) to denote program structure.

The Pure language is a successor of the equational programming language Q,[1] previously created by the same author, Albert Gräf at the University of Mainz, Germany. Relative to Q, it offers some important new features (such as local functions with lexical scoping, efficient vector and matrix support, and the built-in C interface) and programs run much faster as they are compiled just-in-time to native code on the fly. Pure is mostly aimed at mathematical applications and scientific computing currently, but its interactive interpreter environment, the C interface and the growing set of addon modules make it suitable for a variety of other uses, such as artificial intelligence, symbolic computation,[2] and real-time multimedia processing [3]

Pure plug-ins are available for the Gnumeric spreadsheet and Miller Puckette's Pure Data graphical multimedia software, which make it possible to extend these programs with functions written in the Pure language. Interfaces are also provided as library modules to GNU Octave, OpenCV, OpenGL, the GNU Scientific Library, FAUST, SuperCollider, and liblo (for Open Sound Control (OSC)).

## Examples

[edit]

The Fibonacci numbers (naive version):

fib 0 = 0;
fib 1 = 1;
fib n = fib (n-2) + fib (n-1) if n>1;

Better (tail-recursive and linear-time) version:

fib n = fibs (0,1) n with
fibs (a,b) n = if n<=0 then a else fibs (b,a+b) (n-1);
end;

Compute the first 20 Fibonacci numbers:

map fib (1..20);

An algorithm for the n queens problem which employs a list comprehension to organize the backtracking search:

queens n = search n 1 [] with
search n i p  = [reverse p] if i>n;
= cat [search n (i+1) ((i,j):p) | j = 1..n; safe (i,j) p];
safe (i,j) p  = ~any (check (i,j)) p;
check (i1,j1) (i2,j2)
= i1==i2 || j1==j2 || i1+j1==i2+j2 || i1-j1==i2-j2;
end;

While Pure uses eager evaluation by default, it also supports lazy data structures such as streams (lazy lists). For instance, David Turner's algorithm[4] for computing the stream of prime numbers by trial division can be expressed in Pure:

primes = sieve (2..inf) with
sieve (p:qs) = p : sieve [q | q = qs; q mod p] &;
end;

Use of the `&` operator turns the tail of the sieve into a thunk to delay its computation. The thunk is evaluated implicitly and then memoized (using call by need evaluation) when the corresponding part of the list is accessed, e.g.:

primes!!(0..99); // yields the first 100 primes

Pure has efficient support for vectors and matrices (similar to that of MATLAB and GNU Octave), including vector and matrix comprehensions.

Namespaces, types and interfaces belong to the standard repertoire:

nonfix nil;
type bintree nil | bintree (bin x left right);

outfix « »;
namespace foo (« »);
infixr (::^) ^;
x^y = 2*x+y;
namespace;

interface stack with
push s::stack x;
pop s::stack;
top s::stack;
end;

type stack [];

push xs@[] x | push xs@(_:_) x = x:xs;
pop (x:xs) = xs;
top (x:xs) = x;

As a language based on term rewriting, Pure fully supports symbolic computation with expressions. Here is an example showing the use of local rewriting rules to expand and factor simple arithmetic expressions:

expand = reduce with
(a+b)*c = a*c+b*c;
a*(b+c) = a*b+a*c;
end;

factor = reduce with
a*c+b*c = (a+b)*c;
a*b+a*c = a*(b+c);
end;

expand ((a+b)*2); // yields a*2+b*2
factor (a*2+b*2); // yields (a+b)*2

Calling C functions from Pure is very easy. E.g., for a "Hello, World!" program, the following imports the `puts` function from the C library and uses it to print the string `"Hello, world!"` on the terminal:

extern int puts(char*);
hello = puts "Hello, world!";
hello;

Instead of manually compiling source files to LLVM bitcode modules, one can also place the source code into a Pure script, enclosing it in %< ... %> (inline code, e.g. C, Fortran 77/90 and so on).

## See also

[edit]

* Free and open-source software portal

* Functional programming
* Functional languages
* Clean (programming language)

## References

[edit]

* Albert Gräf. "Signal Processing in the Pure Programming Language". Linux Audio Conference 2009.
* Michael Riepe. "Pure – eine einfache funktionale Sprache" Archived 2011-03-19 at the Wayback Machine. Heise.
* "Interview With Albert Gräf". blueparen.
* Mark Boady, Introduction to Term Rewrite Systems and their Applications

## Notes

[edit]

1. ^ Q-Equational-Programming-Language https://q-lang.sourceforge.net/
2. ^ "REDUCE Related Projects". REDUCE Computer Algebra System. Retrieved 2025-01-19.
3. ^ FAUST https://faust.grame.fr/.
4. ^ Turner, David A. SASL language manual. Tech. rept. CS/75/1. Department of Computational Science, University of St. Andrews 1975.

## External links

[edit]

* Official website
* Pure at Github
* The Pure Manual (html)
* The Pure Library Manual (html)
* Documentation Overview (html)
* Computer Algebra with Pure: A Reduce Interface
* Pure quick reference
* Using the Pure Interpreter
* Using Pure with TeXmacs
* The Pure TeXmacs Plugin

* v
* t
* e

Programming languages

* Comparison
* Timeline
* History

* Ada
* ALGOL
* Simula
* APL
* Assembly
* BASIC
* Visual Basic
* classic
* .NET
* C
* C++
* C#
* COBOL
* Erlang
* Elixir
* Forth
* Fortran
* Go
* Haskell
* Java
* JavaScript
* Julia
* Kotlin
* Lisp
* Lua
* MATLAB
* ML
* Caml
* OCaml
* Pascal
* Object Pascal
* Perl
* Raku
* PHP
* Prolog
* Python
* R
* Ruby
* Rust
* SAS
* SQL
* Scratch
* Shell
* Smalltalk
* Swift
* more...

* Lists: Alphabetical
* Categorical
* Generational
* Non-English-based
* Category

*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template