1 List comprehensions

Transkript

1 Hier soll gezeigt werden, wie Domain specific languages (DSL) in Common Lisp implementiert werden können. Dies kann auch als eine andere Art der Programmierung aufgefasst werden. Anstatt ein Problem soweit anzupassen, dass es direkt implementiert werden kann, stellt man sich zunächst eine ideale Sprache vor, in der solche Probleme ausgedrückt und gelöst werden könnten. Dann passt man die Programmiersprache an, schreibt also eine entsprechende DSL, die dieser Idealprache entspricht. Paul Graham bezeichnet diese Art der Programmierung als Bottom Up und schreibt dazu ( It s worth emphasizing that bottom-up design doesn t mean just writing the same program in a different order. When you work bottom-up, you usually end up with a different program. Instead of a single, monolithic program, you will get a larger language with more abstract operators, and a smaller program written in it. Instead of a lintel, you ll get an arch. 1 List comprehensions List comprehensions bezeichnen eine spezielle Syntax, um Listen in deklarativer Art und Weise beschreiben zu können. Dabei orientieren sich list comprehensions an der mathematischen Notation für Mengen: {n 2 n N neven} Heutzutage finden sich list comprehensions in vielen, modernen Programmiersprachen. In Haskell kann die obige Menge, als (unendliche) Liste, z.b. wie folgt definiert werden: [ n n n < [ 1.. ], even n ] List comprehensions stellen damit eine Untersprache von Haskell dar, die nur den speziellen Bereich (domain specific) der Konstruktion von Listen abdecken. Wie jede Programmiersprache besitzen list comprehensions dazu 1 eine eigene Syntax aexp [exp qual 1,..., qual n ] (list comprehension, n 1) qual pat exp (generator) let decls (local declaration) exp (boolean guard) wobei wir hier annehmen, dass exp beliebige Ausdrücke, pat Variablennamen und decls Variablenbindungen der Form beschreiben. decls pat = exp; decls 1 From the Haskell 2010 language reference: haskell2010/haskellch3.html#x

2 und eine eigene Semantik, die in Haskell über Äquivalenzregeln definiert ist: [e True] = [e] [e q] = [e q, True] [e b, Q] = if b then[e Q] else [] ok p = [e Q] [e p l, Q] = let ok = [] [e let decls, Q] = let decls in [e Q] in concatmap ok l wobei e einen Ausdruck, p einen Variablennamen, l einen listenwertigen Ausdruck, b einen booleschen Ausdruck und d Deklarationen bezeichnet. q bezeichnet einen qual-ausdruck, wie in der Syntax von list comprehensions definiert, und Q steht für eine Sequenz solcher Ausdrücke. Weitere Symbole, die in dieser Übersetzung auftauchen, sind der Wahrheitswert True und die Haskell Funktion concatmap, die im Prelude definiert ist. 1.1 Common Lisp Implementierung In Common Lisp können wir Makros benutzen, um unsere eigenen list comprehensions zu definieren. Dazu ist es zunächst einmal nötig die Syntax an die von Lisp verwendete Präfix-Notation anzupassen 2. In Lisp-Notation könnte das obige Beispiel folgendermassen aussehen: ( list comp ( n n ) (< n <naturals >) (evenp n ) ) Wir wollen also ein Makro list-comp schreiben, welches diesen Ausdruck in gültigen Lisp-Code übersetzt. Die Funktion <- soll dabei als spezieller Bezeichner, wie in der Syntax von list comprehensions beschrieben, betrachtet werden Syntaktische Transformation Lisp-Makros können beliebige Lisp Funktionen aufrufen, um Code-Transformationen durchzuführen. Um uns das Leben zu erleichtern schreiben wir also zunächst einige Funktionen, die uns bei der Übersetzung von list comprehensions helfen. Diese Funktionen folgen den obigen Transformationsregeln für Haskell und implementieren jeweils die einzelnen Ersetzungen: ( defun generator? ( qual ) (and ( l i s t p qual ) ( eq ( f i r s t qual ) < ))) 2 Mit Hilfe von sogenannten Reader Macros ist es auch möglich die Syntax von Lisp weitergehend zu ändern. Dies erfordert aber einen erheblich höheren Aufwand und die DSL für list comprehensions fügt sich weniger gut in die Sprache ein, was der Lesbarkeit und Verständlichkeit, insbesondere für erfahrene Lisp-Programmierer, abträglich ist. 2

3 ( defun binding? ( qual ) (and ( l i s t p qual ) ( eq ( f i r s t qual ) l e t ) ) ) ( defun translate list comp ( expr quals ) ( i f ( null quals ) ( l i s t, expr ) ; ; no q u a l i f i e r s ( l e t ( ( q ( f i r s t quals ) ) ( sub code ( translate list comp expr ( rest quals ) ) ) ) ; ; ( sub code ( list comp, expr,@( r e s t q u a l s ) ) ) ) (cond ( ( generator? q ) ( t r a n s l a t e g e n e r a t o r ( second q ) ( third q ) sub code ) ) ( ( binding? q ) ( t r a n s l a t e b i n d i n g ( second q ) sub code ) ) ( t ; ; boolean guard ( translate guard q sub code ) ) ) ) ) ) ( defun t r a n s l a t e g e n e r a t o r ( var l i s t e x p r sub code ) ( l e t ( ( ok (gensym OK ) ) ) ( f l e t ( (, ok (, var ), sub code ) ) (mapcan ( f u n c t i o n, ok ), l i s t e x p r ) ) ) ) ( defun t r a n s l a t e b i n d i n g ( d e c l s sub code ) ( l e t, d e c l s, sub code ) ) ( defun translate guard ( guard sub code ) ( i f, guard, sub code ( ) ) ) Damit können wir unser Makro nun einfach wie folgt definieren: ( defmacro list comp ( expr &body quals ) ( translate list comp expr quals ) ) Aufgabe A: 1. Definieren Sie eine alternative operationale Semantik, die List comprehensions in ein iteratives Programm übersetzt: ( list comp ( n n ) (< n <naturals >) (evenp n ) ) könnte etwa wie folgt übersetzt werden ( l e t ( ( result 123 ( ) ) ) (do ( ( l i s t <naturals >) ( cdr l i s t ) ) ( ( null l i s t ) ) ( l e t ( ( n ( car l i s t ) ) ) (when (evenp n ) 3

4 (push ( n n ) result 123 ) ) ) ) ( reverse result 123 ) ) Hinweis: Überlegen Sie auch kompliziertere Beispiele. Wie sähe Ihre Übersetzung aus, wenn mehrere Generator-Ausdrücke vorkommen. 2. Implementieren Sie Ihre Übersetzung als Common Lisp Makro. Aufgabe B: Finden Sie weitere Beispiele für DSLs in Common Lisp und erklären Sie kurz wozu diese dienen. Was ist mit dem loop Makro und CLOS, dem Common Lisp Object System? Lazy evaluation Unser list comprehension Makro funktioniert zwar, aber im Gegensatz zu Haskell kann es nicht mit unendlichen Listen umgehen. Dies liegt natürlich daran, dass Lisp keine verzögerte Auswertung besitzt und mapcan, die Lisp Entsprechung zu Haskell s concatmap, auf unendlichen Listen nicht terminieren würde. Lisp ist jedoch die programmierbare Programmiersprache und wir können eine (sehr kleine) DSL für verzögerte Auswertung definieren. Diese besteht nur aus zwei Operatoren: (delay <expr>): Verzögert die Auswertung eines Ausdruckes. (force <expr>): Erzwingt die Auswertung eines Ausdruckes. Frage: Können wir delay und force als Funktionen definieren oder benötigen wir dazu Makros? Wir implementieren verzögerte Ausdrücke, indem wir diese als Promise (Versprechen) repräsentieren. Ein Promise ist dabei eine Datenstruktur, die entweder schonmal ausgewertet wurde und einfach einen Wert enthält oder bisher nicht ausgewertet wurde. In diesem Fall enthält sie eine Funktion, die den gewünschten Wert bei Bedarf berechnen kann. ( defstruct pr omi se f o r c e d value ) force kann nun einfach als Funktion implementiert werden. Um uns das Leben zu erleichtern funktioniert diese auch für alle anderen Lisp-Datentypen: ( defun f o r c e ( s t u f f ) ( i f ( promise p s t u f f ) ( i f ( promise forced s t u f f ) 4

5 ( promise value s t u f f ) ( l e t ( ( forced val ( funcall ( promise value s t u f f ) ) ) ) ( setf ( promise forced s t u f f ) t ( promise value s t u f f ) forced val ) ) ) s t u f f ) ) delay müssen wir als Makro implementieren, da es sein Argument nicht direkt auswerten soll, sondern unausgewertet in ein Promise einpacken soll: ( defmacro delay ( expr ) ( make promise : f o r c e d n i l : value ( lambda ( ), expr ) ) ) Damit können wir nun verzögerte Listen implementieren, die damit potentiell unendlich sein können. Da diese eine neue Datenstruktur darstellen müssen wir leider alle Funktionen, die wir dafür benötigen, ebenfalls selber implementieren. Wir folgen hier dem Haskell Prelude: ( defmacro lazy cons ( x xs ) ( delay ( cons, x, xs ) ) ) ( defun empty? ( l l ) ( null ( f o r c e l l ) ) ) ( defun head ( l l ) ( f i r s t ( f o r c e l l ) ) ) ( defun t a i l ( l l ) ( rest ( f o r c e l l ) ) ) ( defun ll map ( f l l ) ( i f ( empty? l l ) ( ) ( lazy cons ( funcall f ( head l l ) ) ( ll map f ( t a i l l l ) ) ) ) ) ( defun take ( n l l ) ( i f ( or (<= n 0) ( empty? l l ) ) ( ) ( cons ( head l l ) ( take (1 n ) ( t a i l l l ) ) ) ) ) ( defun concat ( l l kk ) ( i f ( empty? l l ) kk ( lazy cons ( head l l ) ( concat ( t a i l l l ) kk ) ) ) ) ( defun concat map ( f l l ) 5

6 ( i f ( empty? l l ) ( ) ( l e t ( ( x ( funcall f ( head l l ) ) ) ) ( concat x ( delay ( f o r c e ( concat map f ( t a i l l l ) ) ) ) ) ) ) ) Jetzt müssen wir nur translate-generator umdefinieren, so dass es concat-map benutzt, und schon können unsere list comprehensions mit unendlichen Listen umgehen: ( defun t r a n s l a t e g e n e r a t o r ( var l i s t expr sub code ) ( l e t ( ( ok ( gensym OK ) ) ) ( f l e t ( (, ok (, var ), sub code ) ) ( concat map ( f u n c t i o n, ok ), l i s t expr ) ) ) ) ( defun n a t u r a l s ( ) ( labels ( ( nat ( n ) ( lazy cons n ( nat (1+ n ) ) ) ) ) ( nat 1 ) ) ) ( take 10 ( list comp ( n n ) (< n ( n a t u r a l s ) ) (evenp n ) ) ) 2 Domain specific languages Diese Art der Programmierung ist in Lisp sehr verbreitet, findet aber auch in anderen Sprachen zunehmend Freunde. Viele bekannte Toolkits haben mittlerweile DSL-Charakter, z.b. Ruby on Rails, oder es werden spezifische Programmiersprachen entwickelt, um spezifische Probleme besser ausdrücken und lösen zu können, z.b. Google s go-lang für Nebenläufigkeit oder probabilistische Programmiersprachen wie Stan (mc-stan.org). Die Übergänge zwischen Bibliotheken und DSLs sind oft fliessend. Martin Fowler unterscheidet in einem bekannten Artikel ( com/articles/languageworkbench.html) zwischen internen und externen DSLs: Eine interne DSL ist eingebettet und erweitert die Host-Sprache um zusätzliche Konstrukte und Funktionen, um ihre Problemdomäne einfacher ausdrücken zu können. Interne DSLs sind in Lisp sehr verbreitet und unsere obigen Beispiele fallen in diese Kategorie. Weitere schöne Beispiele sind etwa Das Video von Rainer Joswig, der zeigt wie das Beispiel aus Fowler s Artikel in Lisp implementiert werden kann. Gleichzeitig illustriert er dabei auch die interaktive Arbeitsweise eines erfahrenen Lisp Programmierers. 6

7 Das Buch On Lisp des schon erwähnten Paul Graham enthält viele eindrucksvolle Beispiele der Bottom Up Programmiertechnik, insbesondere eines eingebetteten Prolog. Das Buch ist online verfügbar unter und gilt als Standardwerk über fortgeschrittene Programmiertechniken in Common Lisp. Das Buch Practical Common Lisp von Peter Seibel ist ebenfalls frei verfügbar unter Es ist nicht nur eine sehr gute, moderne Einführung in Common Lisp, sondern enthält auch einige Beispiele für DSLs. Insbesondere Kapital 24 ist sehr lesenswert und entwickelt eine DSL, um binäre Dateiformate zu lesen und schreiben: Ein ID3v2.2-Tag hat folgendes Datenformat: ID3/file identifier ID3 ID3 version $02 00 ID3 flags %xx ID3 size 4 * %0xxxxxxx wobei das Präfix $ eine Hexadezimal und % eine Binärdarstellung bezeichnet. In der Lisp DSL kann dieses Format dann einfach wie folgt spezifiziert werden: ( define binary type id3 tag size ( ) ( unsigned integer : bytes 4 : bits per byte 7 ) ) ( define binary class id3 tag ( ) ( ( i d e n t i f i e r ( iso string : length 3 ) ) ( major version u1 ) ( r e v i s i o n u1 ) ( f l a g s u1 ) ( s i z e id3 tag size ) ) ) Danach können ID3-Tags dann mittels (read-value id3-tag in) und (write-value id3-tag out val) gelesen und geschrieben werden. DSLs sind auch in Haskell weit verbreitet, dort allerdings meist als sogenannte Combinator Libraries. Hierbei wird eine Domäne zunächst mathematisch als Algebra formalisiert und dann in Haskell implementiert. Schöne Beispiel sind etwa eine Algebra für Finanzkontrakte in How to Write a Financial Contract von Simon Peyton Jones und Jean-Marc Eber oder das Darcs Versionskontrollsystem welches auf einer Algebra für Patches aufgebaut ist. Eine externe DSL ist eine eigenständige Sprache, die für eine spezielle Aufgabe entwickelt wurde. Die Implementierung einer externen DSL er- 7

8 fordert einen höheren Aufwand als für eine interne, insbesondere müssen ein Parser sowie Interpreter oder Kompiler entwickelt werden. Dieser Aufwand kann sich jedoch lohnen, wenn die Sprache dadurch einfacher, lesbarer und auch für Laien verwendbar wird. Das bekannteste Beispiel für eine externe DSL ist sicherlich SQL, die Structured Query Language zur Abfrage von relationalen Datenbanken, aber auch Datenformate wie XML oder JSON lassen sich als DSL verstehen und werden vielfach zur Beschreibung von System-Konfigurationen oder in Dependency Injection Frameworks eingesetzt. 8