What is a model METAPROGRAMMING. ! Descrip5on/abstrac5on of real world things. ! Abstract representa5on that can be manipulated by a program 11/22/13

Transcription

1 METAPROGRAMMING What is a model! Descrip5on/abstrac5on of real world things o Something with a descrip5on of how it should be structured o Objects & rela5onships (a graph?)! Abstract representa5on that can be manipulated by a program o Can be easier to modify or work with o Simula5on (cost) o Abstrac5on of a process o Abstrac5on of something that does not exist yet 1

2 Models and metamodels Reflec5on, Introspec5on! Reflec/on is the ability of a program to manipulate as data something represen5ng the state of the program during its own execu5on.! Introspec/on is the ability for a program to observe and therefore reason about its own state.! Intercession (adap/on) is the ability for a program to modify its own execu5on state or alter its own interpreta6on or meaning.! All aspects require a mechanism for encoding execu5on state as data: this is called reifica'on. 2

3 Models and Metamodels Metaprogramming! The term metaprogramming covers almost any situa5on where a program manipulates code, either its own or that of some other program. This may happen in many ways. o Textual manipula5on of code as strings (Javascript eval) o Code genera5on at compile 5me or run 5me (JIT compilers) o Self- modifying code (Autonomic Compu5ng) o Staged computa5on (Par5al Evalua5on)! Strictly speaking, any compiler or interpreter would qualify as a metaprogram.! Here, the no5on of metaprogramming will refer to specific language features 3

4 metaprogramming Metaprogramming Examples #define MULT(x, y) x * y MACRO in C int z = MULT(3 + 2, 4 + 2); What value do you expect z to end up with? The obvious answer is 30 int z = * 4 + 2; // 2 * 4 will be evaluated first! Code inlining 4

5 MACRO in C #define MULT(x, y) (x) * (y) MULT(3 + 2, 4 + 2) will expand to (3 + 2) * (4 + 2) Metaprogramming Examples for(i = 0; i < n; i++)... The non- syntac5c UpTo macro Builds code at compile 5me #define UpTo(i, n) for((i) = 0; (i) < (n); (i)++) UpTo(i, 10)... 5

6 Metaprogramming Examples C++ Templates Template<int n> Vector<n> add(vector<n> lhs, Vector<n> rhs) { Vector<n> result = new Vector<n>; for (int i = 0; i < n; ++i) result.value[i] = lhs.value[i] + rhs.value[i]; return(result) } Template: general rou5ne for adding vectors of arbitrary length C++ STL does a lot of compile 5me specializa5on import java.io.* import java.lang.reflect.*; Class c = Class.forName("java.lang.System"); // Fetch System class Field f = c.getfield("out"); // Get sta5c field Object p = f.get(null); // Extract output stream Class cc = p.getclass(); // Get its class Class types[] =newclass[] { String.class}; // Iden5fy argument types Method m = cc.getmethod("println", types); // Get desired method Object a[] = new Object[] { "Hello, world" }; // Build argument array m.invoke(p,a); //Invoke method J A V A 6

7 Java Class Loading public class MainClass { } public sta5c void main(string[] args){ ClassLoader classloader = MainClass.class.getClassLoader(); try { Class aclass = classloader.loadclass("com.giangi.myclass"); System.out.println("aClass.getName() = " + aclass.getname()); } catch (ClassNotFoundExcep5on e) { e.printstacktrace(); } INTERMEZZO: LISP 7

8 Lisp Milestones! Late 1950's: LISP (LISt Processor) invented by John McCarthy et al. at MIT for the purpose of AI research.! 1960: landmark paper introducing LISP to the wider world: "Recursive Func5ons of Symbolic Expressions and Their Computa5on by Machine! 1974: Pisa MagmaLisp! 1975: Scheme invented by Guy Steele and Gerald Sussman.! Mid- 1980's: Non- Scheme Lisp dialects (principally Maclisp and Interlisp) standardized into "Common Lisp".! Late- 1980's: Common Lisp Object System adds OOP constructs to Common Lisp.! 1998: R 5 RS (5th revised report on Scheme) defines the Scheme standard s5ll in use today. 8

9 Lisp Big Ideas! Many of the major good ideas we've seen in programming languages originated in dialects of Lisp: o garbage collec5on, uniform by- reference data model, strong typing, lists as a pervasive data structure, heavy use of higher- order, anonymous, and recursive func5ons.! Programs are data: Lisp programs are themselves lists, and Lisp has special syntaxes for represen5ng "unevaluated list data". It is therefore easy to represent Lisp programs as Lisp data, and so Lisp lends itself to metaprogramming (wri5ng programs that manipulate other programs) easy.! Simplicity and regularity above all: Scheme demonstrates how small a language can be while remaining powerful and expressive.! Hygienic syntax macros: The Scheme syntax is extensible through a macro system that (unlike, for example, C macros) is rela5vely safe and has a clean seman5cs that fits in well with the rest of the language. Syntax program ::= S* S ::= atom list atom ::= IDENTIFIER NUMBER SYMBOL STRING... list ::= ( S* ) An s- expression is either an atom or a list. Atoms include variable names and literal values. A list is a sequence of whitespace- separated s- expressions inside round parens 9

10 (+ 1 2) ; sum of 1 and 2 ( ) ; sum of 1, 2, and 3; (cons 1 ()) ; 1 consed onto nil () (list 1 2 3) ; The list (cons 1 (cons 2 (cons 3 ()))) ;; Lists can be heterogeneous (list 1 "hi" 'a #f) (list 0 (list 1 2)) ;; (car (list 1 2 3)) ; car is the equivalent of "hd" (cdr (list 1 2 3)) ; cdr is the equivalent of "tl" (lambda (x) (+ x 1)) ; anonymous func5ons ((lambda (x) (x + 1)) 2) ; applies func5on to 2 (define add (lambda (x y) (+ x y))) ; binds name add to func5on map (define (mymap f alist) (if (null? alist) () (cons (f (car alist)) mymap f (cdr alist))))) 10

11 Car? Cadr? Historical note: car and cdr come from the names of the assembly language instruc5ons used to implement them in 1959 on the IBM 704: CAR was the opcode for "contents of the address register", CDR was the opcode for "contents of the decrement register". The terminology is horrible but has stayed with us to this day. Set and ref SCHEME ML (define x 5) ; val x = ref 5 (define y x) ; val y = ref (!x) (set! x 4) ; x := 4 x ;!x; y ;!y; 11

12 QUOTE Scheme has a convenient syntax for represen5ng data literals: prefix any expression with ' (single quote) and the expression, rather than being evaluated, will be returned as data S- Expression ; => Evaluated result '3 ; => 3 (a number) '"hi" ; => "hi" (a string) 'a ; => a (a symbol) '(+ 3 4) ; => (list '+ '3 '4) (a list) '(a b c) ; => (list 'a 'b 'c) (a list) QUOTE '(lambda (x) (+ x 3)) (a list) ; => (list 'lambda (list 'x) (list '+ 'x '3)) ; => (list 'lambda (list 'x) (list '+ 'x 3)) "quoted" data remains unevaluated, and provides a convenient way of represen5ng programs. Since programs themselves are lists, it is extremely simple to represent Lisp programs as data. 12

13 QUOTE names in Lisp programs are translated into symbols in quoted Lisp expressions. quoted names can be dis5nguished from quoted strings; : '(define x 10) ; => (list 'define 'x 10) '("define" x 10) ; => (list "define" 'x 10) QUASIQUOTE the ` (backquote) operator, also called quasiquote with the, (comma) operator, also called unquote. Quasiquote behaves like quote, except that unquoted expressions are evaluated: `(1 2,(+ 3 4)) ; => '(1 2 7) 13

14 Special forms (quote (1 2 (+ 3 4))) ; => '(1 2 (+ 3 4)) (quasiquote (1 2 (unquote (+ 3 4)))) ; => '(1 2 7) EVAL Since we have a method for represen5ng programs as data, it is convenient to have a func5on that evaluates that data as if it were a part of the currently running program Eval in DrScheme: (define x 5) (define y '(+ x 10)) (eval y) ; => 15 (eval '((lambda (x y) (string- concat x y)) "foo" "bar")) ; => "foobar" 14

15 The Scheme Interpreter in Scheme (define (eval exp env) (cond ((self- evalua5ng? exp) exp) ((quoted? exp) (text- of- quota5on exp)) ((variable? exp) (lookup- variable- value exp env)) ((defini5on? exp) (eval- defini5on exp env)) ((assignment? exp) (eval- assignment exp env)) ((lambda? exp) (make- procedure exp env)) ((condi5onal? exp) (eval- cond (clauses exp) env)) ((applica5on? exp) (apply (eval (operator exp) env) (list- of- values (operands exp) env))) (else (error "Unknown expression type - - EVAL" exp)))) (define (apply procedure arguments) (cond ((primi5ve- procedure? procedure (apply- primi5ve- procedure procedure arguments))) ((compound- procedure? procedure) (eval- sequence (procedure- body procedure) (extend- environment (parameters procedure) arguments (procedure- environment procedure)))) (else (error "Unknown procedure type - - APPLY" procedure)))) 15

16 END INTERMEZZO (LISP) JS EVAL eval("3+4"); // Returns 7 a= "5 ";b="2"; eval(a+b); // Returns 3, result of 5 2 eval(b+a); // Run5me syntax error a= "5 "; b = "1"; c = "a+a+b"; eval(c); // Returns the string "5-5- 1" eval(eval(c)) //Returns the number

17 JS Eval var foo = 1; func5on test() { var foo = 2; eval('foo = 3'); return foo; } test(); // 3 foo; // 1 JS Eval var strfun = "func5on myfun(arg) { return arg * 3; }"; eval(strfun); func5on usefun(x) { var res = myfun(x); alert(res); } 17

18 ML+++MACRO let fun pow n x = if n = 0 the 1 else x * (pow (n- 1) x) in pow (2*3) (5+6) let mac pow n x = if n = 0 the 1 else x * (pow (n- 1) x) pow (2*3) (5+6) espands into if (2*3) = 0 the 1 else (5+6) * (pow ((2*3)- 1) (5+6))... metaml let mac pow ~n x = ~(if n = 0 the <1> else <x * ~(pow (n- 1) x)>) In pow ~(2*3) (5+6) Escape ~e escape from macro expansion to evalua5on mode Bracket <e> interrupts evalua5on and return to the macro expansion mode (5+6) * (5+6) * (5+6) * (5+6) * (5+6) * (5+6) * 1 18

19 MetaOCaml # let x =.<4 + 2>. ;; val x: int code =.<4 + 2>. # let y =.<.~x +.~x>. ;; val y int code = <(4 + 2) + (4 + 2)>. #let z =.! Y;; val z : int = 12 Quote.<e>. An5quote.~ Execute.! Staged Programming Languages! MetaMl (MetaOCaml) are examples of mul5 stage programming languages provoding suitable abstrac5ons and control over exactly what parts are evaluated when in the chain from source to execu5on 19

20 F# IN PILLOLE F#! F# is a func5onal (and object oriented) language for the.net framework. let rec fact n = match n with 0 - > 1 n - > n * fact (n- 1) Approxima5on: F# is Ocml with.net libraries and CLR. MSIL,.. 20

21 F# at MSR! F# brings you type safe, succinct, efficient and expressive func5onal programming language on the.net pla~orm. It is a simple and pragma5c language, and has par5cular strengths in data- oriented programming, parallel I/O programming, parallel CPU programming, scrip5ng and algorithmic development. It lets you access a huge.net library and tools base and comes with a strong set of Visual Studio development tools. F# combines the advantages of typed func5onal programming with a high- quality, well- supported modern run5me system. F#! Interoperability with the.net framework and other.net languages is central to F#.! Core syntax is OCaml: with higher- order func5ons, lists, tuples, arrays, records,...! Objects are as in C#: with classes, inheritance, dot nota5on for field and method selec5on,...!.net toys (aka powerful tools): extensive libraries, concurrent garbage collector, install- 5me/run- 5me (JIT) compila5on, debuggers, profilers,...! Creates and consumes.net/c# types and values; can call and be called from other.net languages.! Generates and consumes.net code: can exchange first- class func5ons with other languages. 21

22 Metaprogramming in F#! D. Syme Leveraging.NET meta- programming components from F#: Integrated queries and interoperable heterogeneous execu5on. In ML 06: Proceedings of the ACM SIGPLAN 2006 Workshop on ML, pages ACM Press, September Quota5on in F# > open Microso.Fsharp.Quota5ons let q = <@ * val q : Quota5ons.Expr<int> = Call (None, op_addi5on, [Value (2), Call (None, op_mul5ply, [Value (2), Value (3)])]) F# provides explicit quota5on markers (as in LISP, MetaML and MetaOCaml) 22

23 > let w = <@ while true do prin~n "It never let f = <@ fun x y - > x + val w : Quota5ons.Expr<unit> = WhileLoop (Value (true), Call (None, PrintFormatLine, [Coerce (NewObject (Prin~Format`5, Value ("It never ends...")), Prin~Format`4)])) val f : Quota5ons.Expr<(int - > int - > int)> = Lambda (x, Lambda (y, Call (None, op_addi5on, [x, y]))) > open Microso.FSharp.Quota5ons open Microso.FSharp.Quota5ons.Paƒerns open Microso.FSharp.Quota5ons.DerivedPaƒerns let rec evalexpr q = match q with SpecificCall <@ (_, _, [a; b]) - > let l, r = evalexpr a, evalexpr b l + r SpecificCall <@ (_, _, [a; b]) - > let l, r = evalexpr a, evalexpr b l * r Value (v, t) - > if t = typeof<int> then v :?> int else failwith "Only integer values supported" _ - > failwith "Unsupported expression" 23

24 MORE INFO ON 24