Dylan makroer / JSE Andreas Kirkeskov Carlsen 27. april 2005

Dylan makroer Hvad er Dylan makroer? Hvorfor Dylan makroer?

Dylan makroer Hvad er Dylan makroer? Hvorfor Dylan makroer? Dylan makroer er omskrivningsregler (rewrite rules) bestående af patterns og pattern-variables. Dylan makroer tillader programmører at udvide Dylan sproget, f.eks. ved at tillade nye kontrolstrukturer og definitioner.

Dylan makroer Makroer defineres ved: define macro konstant-modul-binding makro-definition

Dylan makroer ”Dylan has three kinds of macros:

Dylan makroer ”Dylan has three kinds of macros: definition macros, which extend the available set of definitions;

Dylan makroer ”Dylan has three kinds of macros: definition macros, … statement macros, which extend the available set of statements;

Dylan makroer ”Dylan has three kinds of macros: definition macros, … statement macros, … function macros, which syntactically resemble function calls but are more flexible.”

Dylan makroer Definitionsmakroer?

Dylan makroer Definitionsmakroer? Venstre-side-pattern’et skal defineres som define modifiers opt DEFINE-BODY-WORD body-fragment opt definition-tail eller define modifiers opt DEFINE-LIST-WORD list-fragment opt Konstant-modul-bindingen skal bestå af DEFINE-BODY-WORD eller DEFINE- LIST-WORD og suffix’et ”-definer”.

Dylan makroer Definitionsmakroer? Eksempel 1 : define macro named-color-definer { define named-color ?:name = ( ?red:expression, ?green:expression, ?blue:expression ) } => { *default-named-color-table*[?#”name”] := make-rgb-color( ?red / 255.0, ?green / 255.0, ?blue / ) } end macro; bruges som: define named-color silver = ( 204, 204, 204 ) og ekspanderer til *default-named-color-table*[ #”silver” ] := make-rgb-color( 0.8, 0.8, 0.8 ) 1 Fra

Dylan makroer Statementmakroer?

Dylan makroer Statementmakroer? Venstre-side-pattern’et skal defineres som BEGIN-WORD body-fragment opt end-clause Konstant-modul-bindingen kan være hvad som helst, men det er (så vidt jeg kan se) generelt det samme som BEGIN-WORD.

Dylan makroer Statementmakroer? Eksempel: define macro color-switch { color-switch ( ?test:expression ) ?:color-switch-body end color-switch } => { begin let temp = ?test; ?color-switch-body end } color-switch-body: { (?:color-list) => ?:body … } => { if (member?(temp, ?color-list)) ?body else … end if } { otherwise ?:body } => { ?body } { } => { #f } color-list: { ?:name, … } => { pair( color(?:name), … ) } { } => { empty-list } end macro; bruges som: color-switch ( color(red) ) (red green blue) => 1; otherwise 2; end color-switch; og ekspanderer til begin let temp = color(red); if (member?(temp, list(color(red), color(green), color(blue)) 1; else 2; end if; end;

Dylan makroer Funktionsmakroer?

Dylan makroer Funktionsmakroer? Venstre-side-pattern’et skal defineres som FUNCTION-WORD ( body-fragment opt ) Konstant-modul-bindingen kan være hvad som helst, men det er (så vidt jeg kan se) generelt det samme som FUNCTION-WORD.

Dylan makroer Funktionsmakroer? Eksempel: define macro color { color ( ?:name ) } => { *default-named-color-table*[?#”name”] } bruges som: color(blue) og ekspanderer til *default-named-color-table*[ #”blue” ]

Dylan makroer Dylan makroer er

Dylan makroer Dylan makroer er fuldt programmerbare (Turing-komplette)

Dylan makroer Fuldt programmerbare - Lambda-calculus kan implementeres i Dylan makroer define macro equal { equal([], []) } => { true } { equal([?:expr], []) } => { false } {equal([], [?:expr]) } => { false } {equal([?a:expr], [?b:expr])} => { equal(?a, ?b) } end macro; define macro test { test(true, ?cons:expr, ?alt:expr) } => { ?cons } { test(false, ?cons:expr, ?alt:expr) } => { ?alt } end macro; define macro lookup { lookup(?n:expr; empty) } => { Crash } { lookup(?n:expr; ?m:expr, ?denot:expr, ?r:*) } => { test(equal(?n, ?m), ?denot, lookup(?n; ?r)) } end macro; define macro eval { eval(var(?n:expr); ?r:expr) } => { lookup(?n; ?r) } { eval(lambda(?n:expr, ?b:expr); ?r:*) } => { closure(?n, ?b, ?r) } { eval(app(closure(?n1:expr, ?b1:expr, ?r1:*), closure(?n2:expr, ?b2:expr, ?r2:*)); ?r) } => { eval(?b1; ?n1, closure(?n2, ?b2, ?r2), ?r1) } { eval(app(?f:expr, ?arg:expr); ?r:*) } => { eval(app(eval(?f; ?r), eval(?arg; ?r)); ?r) } end macro; Fra

Dylan makroer Dylan makroer er fuldt programmerbare (Turing-komplette) ikke AST-manipulerende, men symbol- træs-manipulerende (a la lisp) –Kender ikke til sprogkonstruktioner Kan derfor ikke give fejlmeddelelser på macro- expansion-time, men først på compile-time

Dylan makroer Symbol-træs-manipulerende – begge de følgende eksempler er lovlige: define macro legal { legal (?test:expression) ?:body end legal } => { if (?test) ?body end if } end macro; define macro also-legal { also-legal (?test:expression) ?:body end also-legal } => { () (if) () (?test) () (?body) () } end macro; men kun den første ekspanderer til lovlig kode.

Dylan makroer Dylan makroer er fuldt programmerbare (Turing-komplette) ikke AST-manipulerende, men symbol- træs-manipulerende (a la lisp) –Kender ikke til sprogkonstruktioner Kan derfor ikke give fejlmeddelelser på macro- expansion-time, men først på compile-time hygiejniske –Dog med mulighed for at tilsidesætte dette

Dylan makroer Hygiejniske -”each named value reference in a macro expansion means the same thing as it meant at the place in the original source code from which it was copied into the macro expansion.”

JSE JSE er et makrosystem til Java baseret på Dylan makroer. Da definitionsmakroer ikke giver mening i Java- sammenhæng er disse ikke en del af JSE. Makroer kan benytte alle dele af Java-sproget

JSE På makro-ekspansionstid opbygges først et SST – et ”skeleton syntax tree”

JSE På makro-ekspansionstid opbygges først et SST – et ”skeleton syntax tree” Dette kan ses som en symbol- repræsentation af javakode i stil med quote-opbyggede træer i lisp-varianter.

JSE På makro-ekspansionstid opbygges først et SST – et ”skeleton syntax tree” Dette kan ses som en symbol- repræsentation af javakode i stil med quote-opbyggede træer i lisp-varianter. Som intern repræsentation anvendes Fragment-objekter.

JSE For at lette arbejdet med makroer er et quote-system bygget oven på: #{ } svarer til ´( ) i lisp (quasiquote) ? svarer til, i lisp (unquote og unquote-splicing)

JSE JSEs ekspansionsmekanisme er bygget op i 2 faser: Først ekspanderes og kompileres makrodefinitionerne, dernæst makroanvendelserne ved hjælp af de kompilerede makrodefinitioner.

JSE JSE tillader programmøren at glemme den abstrakte syntax og kun være opmærksom på den konkrete syntax modsat Weise og Crew’s makrosystem JSE giver fuld adgang til Java’s konstruktioner og datastrukturer modsat Brabrand/Schwartzbach’s makrosystem, som til gengæld sikrer lovlige ekspansioner