PicoLisp

PicoLisp ist ein Open Source Lisp-Dialect. Es läuft auf Linux und anderen POSIX-kompatiblen Systemen.

Inhaltsverzeichnis

1 Eigenschaften
2 Geschichte
3 Beispiele
4 Weblinks
5 Quellen
6 Andere Wikipedia Sprachen
7 Init-Quelle

Übrigens: Die PlusPedia ist NICHT die Wikipedia.
Wir sind ein gemeinnütziger Verein, PlusPedia ist werbefrei. Wir freuen uns daher über eine kleine Spende!

1 Eigenschaften

Das grundlegende Prinzip von PicoLisp ist "Einfachheit". Es beschränkt sich auf einen einzigen internen Datentyp (die "Zelle", engl. "cell"), ohne dabei Abstriche an Flexibilität oder Ausdruckskraft zu machen. Auf der Ebene der Sprache existieren nur drei Datentypen (Zahlen, Symbole und Listen), die wiederum aus den internen Zellen aufgebaut sind.

Da die verkettete Liste der einzige nicht-atomare Datentyp ist, existieren viele miteinander kooperierenden Funktionen, die sich ganz auf die Listenverarbeitung konzentrieren können. Im Ergebnis sind PicoLisp-Programme oft prägnanter - und dabei schneller - als jene in anderen interpretierten Sprachen (siehe "Beispiele" unten).

Funktionen sind frei von Compiler-Beschränkungen, und können somit Argumente jedes Typs und von beliebiger Anzahl akzeptieren. Macros werden nur in seltenen Fällen benötigt.

Eine Besonderheit ist die eingebaute Datenbank. Persistente Symbole sind first-class Objekte, sie werden beim Zugriff automatisch aus Datenbankdateien geladen, und nach Veränderungen zurückgeschrieben. Anwendungen können auf eine Klassenhierarchie von Entity-Relationships zurückgreifen.

Ausserdem: Prolog-Interpreter für deklarative Programmierung und Datenbankabfragen, verteilte Datenbanken, direktes Inlining von C-Funktionen und nativer Aufruf externer C-Funktionen, Verwaltung von Child-Prozessen, Interprozesskommunikation, Browser GUI, Lokalisierung.

2 Geschichte

PicoLisp wurde ursprünglich in den 1980er Jahren auf dem Apple Macintosh entwickelt, und wird seitdem in kommerzieller Anwendungsentwicklung eingesetzt. Es wurde bald nach MS-DOS und SCO Unix portiert, und seit 1993 hauptsächlich unter Linux benutzt. Die Datenbankfunktionalität wurde Mitte der 1990er Jahre hinzugefügt.

Während die ersten Versionen in einer Mischung aus C und Assembler geschrieben waren, erfolgte 1999 eine Neu-Implementation ausschließlich in C. Diese Version wurde 2002 unter der GNU GPL Lizenz veröffentlicht.

2009 wurde die 64-bit-Version veröffentlicht, eine nochmalige Neu-Implementation, dieses Mal in einer generischen Assembler-Sprache welche wiederum in PicoLisp implementiert ist.

3 Beispiele

Das folgende Programm implementiert den "Fannkuch" Benchmark, wie er in der [http://shootout.alioth.debian.org/u64q/benchmark.php?test=fannkuch Alioth Benchmark Suite] beschrieben ist:

#!bin/picolisp lib.l

(let (N (format (opt))  Lst (range N 1)  L Lst  M)
   (recur (L)  # Permute
      (if (cdr L)
         (do (length L)
            (recurse (cdr L))
            (rot L) )
         (let I 0  # For each permutation
            (and (ge0 (dec (30))) (prinl (reverse Lst)))
            (for (P (copy Lst)  (> (car P) 1)  (flip P (car P)))
               (inc 'I) )
            (setq M (max I M)) ) ) )
   (prinl "Pfannkuchen(" N ") = " M)
   (bye) )

Es zeigt wie expressiv und prägnant ein PicoLisp-Programm sein kann, im Vergleich mit anderen Beiträgen auf der Alioth-Seite.

Im Gegensatz zu dem autonomen Skript oben, hier das gleiche Programm als Funktionsdefinition:

(de fannkuch (N)
   (let (Lst (range 1 N)  L Lst  Max)
      (recur (L)  # Permute
         (if (cdr L)
            (do (length L)
               (recurse (cdr L))
               (rot L) )
            (zero N)  # For each permutation
            (for (P (copy Lst)  (> (car P) 1)  (flip P (car P)))
               (inc 'N) )
            (setq Max (max N Max)) ) )
      Max ) )

Die Ausführungsgeschwindigkeit ist natürlich geringer als die der meisten compilierten Sprachen. Wir konnten 18 Minutes auf einem 1.0 GHz Athlon messen; es sollte deutlich weniger auf der Intel Q6600 Maschine von Alioth sein. Da es sich dort um einen Quad-Core-Rechner handelt, kann es leicht um einen Faktor von vier beschleunigt werden, wenn man die parallelisierte Version verwendet:

(de fannkuch (N)
   (let (Res (need N)  Lst (range 1 N)  L Lst  Max)
      (for (R Res R (cdr R))
         (later R
            (let L (cdr Lst)
               (recur (L)  # Permute
                  (if (cdr L)
                     (do (length L)
                        (recurse (cdr L))
                        (rot L) )
                     (zero N)  # For each permutation
                     (for (P (copy Lst)  (> (car P) 1)  (flip P (car P)))
                        (inc 'N) )
                     (setq Max (max N Max)) ) )
               Max ) )
         (rot Lst) )
      (wait NIL (full Res))
      (apply max Res) ) )