Pure (Programmiersprache) – Wikipedia

before-content-x4

Rein
Pure lang logo.png
Paradigma Funktionale, deklarative Umschreibung von Begriffen
Entworfen von Albert Gräf
Entwickler Albert Gräf
Erstmals erschienen 2008;; vor 12 Jahren ((2008)
Stabile Version

0,68 / 11 April 2018;; vor 2 Jahren ((2018-04-11)

Schreibdisziplin Stark, dynamisch
Betriebssystem Plattformübergreifend: FreeBSD, GNU / Linux, macOS, Windows
Lizenz GNU Lesser General Public License
Webseite Agraef.github.io/ pure-lang/.
Beeinflusst von
Q, Haskell, Lisp, Alice, MATLAB

ReinNachfolger der Gleichungssprache Q.ist eine dynamisch typisierte, funktionale Programmiersprache, die auf dem Umschreiben von Begriffen basiert. Es verfügt über Funktionen für benutzerdefinierte Operatorsyntax, Makros, Arithmetik mit beliebiger Genauigkeit (Zahlen mit mehrfacher Genauigkeit) und das Kompilieren zu nativem Code über die LLVM. Pure ist freie und Open-Source-Software, die (meistens) unter der GNU Lesser General Public License Version 3 oder höher vertrieben wird.

Pure wird mit einem Interpreter und Debugger geliefert, bietet automatische Speicherverwaltung, verfügt über leistungsstarke funktionale und symbolische Programmierfähigkeiten und Schnittstellen zu Bibliotheken in C (z. B. für numerische, Low-Level-Protokolle und andere solche Aufgaben). Gleichzeitig ist Pure a klein Sprache von Grund auf neu entwickelt; Der Interpreter ist nicht groß und die Bibliotheksmodule sind in Pure geschrieben. Die Syntax von Pure ähnelt der von Miranda und Haskell, ist jedoch eine Sprache im freien Format und verwendet daher explizite Trennzeichen (anstelle von Absätzen außerhalb der Seite), um die Programmstruktur zu kennzeichnen.

Die reine Sprache ist ein Nachfolger der gleichwertigen Programmiersprache Q, die zuvor vom selben Autor, Albert Gräf, an der Universität Mainz erstellt wurde. Im Vergleich zu Q bietet es einige wichtige neue Funktionen (wie lokale Funktionen mit lexikalischem Gültigkeitsbereich, effizienter Vektor- und Matrixunterstützung und der integrierten C-Schnittstelle), und Programme werden viel schneller ausgeführt, da sie just-in-time zu nativem Code kompiliert werden on the fly. Pure richtet sich derzeit hauptsächlich an mathematische Anwendungen und wissenschaftliches Rechnen. Aufgrund seiner interaktiven Interpreter-Umgebung, der C-Schnittstelle und der wachsenden Anzahl von Addon-Modulen eignet sich Pure jedoch für eine Vielzahl anderer Anwendungen wie künstliche Intelligenz, symbolische Berechnung und Echtzeit Multimedia-Verarbeitung.

Für die Gnumeric-Tabelle und die grafische Multimedia-Software Pure Data von Miller Puckette sind reine Plug-Ins verfügbar, mit denen diese Programme um Funktionen erweitert werden können, die in der Sprache Pure geschrieben sind. Schnittstellen werden auch als Bibliotheksmodule für GNU Octave, OpenCV, OpenGL, die GNU Scientific Library, FAUST, SuperCollider und liblo (für Open Sound Control (OSC)) bereitgestellt.

Beispiele[edit]

Die Fibonacci-Zahlen (naive Version):

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

Bessere (schwanzrekursive und lineare Zeit) 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;

Berechnen Sie die ersten 20 Fibonacci-Zahlen:

map fib (1..20);

Ein Algorithmus für das Problem der n Königinnen, der ein Listenverständnis verwendet, um die Backtracking-Suche zu organisieren:

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;

Während Pure standardmäßig eine eifrige Auswertung verwendet, unterstützt es auch verzögerte Datenstrukturen wie Streams (verzögerte Listen). Zum Beispiel der Algorithmus von David Turner[1] zur Berechnung des Stroms von Primzahlen durch Versuchsteilung kann in Rein ausgedrückt werden:

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

Verwendung der & Der Bediener verwandelt den Schwanz des Siebs in einen Rumpf, um seine Berechnung zu verzögern. Der Thunk wird implizit ausgewertet und dann gespeichert (unter Verwendung der Call-by-Need-Bewertung), wenn auf den entsprechenden Teil der Liste zugegriffen wird, z.

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

Pure bietet eine effiziente Unterstützung für Vektoren und Matrizen (ähnlich wie bei MATLAB und GNU Octave), einschließlich Vektor- und Matrixverständnis. Beispielsweise kann ein Gaußscher Eliminierungsalgorithmus mit teilweisem Schwenken in Pure folgendermaßen implementiert werden:

gauss_elimination x::matrix = p,x
when n,m = dim x; p,_,x = foldl step (0..n-1,0,x) (0..m-1) end;

step (p,i,x) j
= if max_x==0 then p,i,x else
    // updated row permutation and index:
    transp i max_i p, i+1,
    {// the top rows of the matrix remain unchanged:
     x!!(0..i-1,0..m-1);
     // the pivot row, divided by the pivot element:
     {x!(i,l)/x!(i,j)                 | l=0..m-1};
     // subtract suitable multiples of the pivot row:
     {{x!(k,l)-x!(k,j)*x!(i,l)/x!(i,j) | k=i+1..n-1; l=0..m-1}}
when
  n,m = dim x; max_i, max_x = pivot i (col x j);
  x = if max_x>0 then swap x i max_i else x;
end with
  pivot i x = foldl max (0,0) [j,abs (x!j)|j=i..#x-1];
  max (i,x) (j,y) = if x

Als Sprache, die auf dem Umschreiben von Begriffen basiert, unterstützt Pure die symbolische Berechnung mit Ausdrücken vollständig. Hier ist ein Beispiel, das die Verwendung lokaler Umschreibregeln zum Erweitern und Faktorisieren einfacher arithmetischer Ausdrücke zeigt:

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

Das Aufrufen von C-Funktionen von Pure aus ist sehr einfach. ZB importiert das Folgende das puts Funktion aus der C-Bibliothek und verwendet sie zum Drucken der Zeichenfolge "Hello, world!" auf dem Terminal:

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

Siehe auch[edit]

Verweise[edit]

  1. ^ Turner, David A. SASL Sprachhandbuch. Technik. rept. CS / 75/1. Institut für Computerwissenschaft, University of St. Andrews 1975.

Externe Links[edit]


after-content-x4