tim sheard oregon graduate institute

Tim SheardOregon Graduate Institute

Lecture 2: More on MetaML

CS510 Sect FSCCS510 Sect FSC

Winter 2004Winter 2004

2Cs510 FSC, Winter 2005

Assignment #1

The first assignment is now posted.See the class home page for details.Assignment due Thursday Jan 13, 2005

Talk to me or call me immediately if you have trouble installing MetaML or MetaOcaml. Try it today, not being able to install is not an acceptable excuse. I’ll help you if you have trouble.


Notes on how to give a paper presentation

Presentation should have several parts What kind of paper is it? What previous work is necessary to

understand this paper? What is it about (a summary)

What is the problem Structure of paper What examples are used? What is new? What is important?


What kind of paper is it?There are lots of kinds of papers, try and pin down what kind is it.

New idea – the paper introduces a new concept that hasn’t been studied before. Often opens up a new area of research. Such papers are uncommon.

Synthesis – the paper synthesizes several old ideas into a new coherent whole. Might use the old ideas in completely new contexts.

Extension – the paper extends previous work in an incremental manner, that strengthens it, or makes it applicable in new contexts. Very common.

Unifying – the paper takes ideas from often very different domains and shows that they are really the same idea in different guises. Rare but very useful as it increases understanding.

Systems Engineering – the paper describes a large complex system. Deep thought usually went into designing the system to meet conflicting goals. The usefulness of the paper is in how it makes tradeoffs between the conflicting goals.

Analysis or Measurement – the paper measures the performance or other aspect of a system in order to evaluate the system. Measurement papers often measure competing systems as a way of comparison.

This list is not complete . . .


Previous work necessary

What ideas do you have to already know to appreciate and understand the paper.Often useful in putting the paper in context of larger surrounding work


SummaryThe summary lets you describe what the paper is about. A retelling of the paper isn’t necessary. Instead recap

The problem. What problem is the paper trying to solve? Why is it important.

Structure. How was the story told. If there was an intro, what points are made, are there measurements, tables, or proofs.

Examples. Examples often provide the greatest insight for unknowledgable readers. Which ones are used, recap them if they are good ones.

What’s New. What new knowledge does the paper provide, if any. It there isn’t anything new, then what else makes the paper interesting.

What’s Important? A good paper makes this obvious, the author spells it out, but sometimes the importance of a paper grows with time. Try and convince the class why they should care about this paper.


Cross-stage PersistenceSometimes called lexical-capture

The source of the mysterious %

-| let val x = 6 in <x + 5> end;val it = <%x %+ 5> : <int>

Free variables in code evaluate to constants in the code constructed. The %X indicates that the object is a constant and originated from a lexically bound variable called X


Cross-stage Persistence cont.

Two cross-stage constants can look the same, but be two different values:

-| let val x = let val y = 4 in <y> end

val z = let val y = true in <y> end

in < (~x , ~ z) > end;

val it = <(%y,%y)> : <(int * bool)>


Lift v.s. lexical captureLift cannot be used on functions-| lift id;Error: The term: id Non Qualified type, not liftable: ? -> ?

Lift makes code readable-| fun f x = <(x, ~(lift x))>;val f = Fn : ['b^].'b -> <('b * 'b )>-| f 3;val it = <(%x,3)> : <(int * int)>

Lexical capture is more efficient-| lift [1+3,4,8-4];val it = <4 :: (4 :: (4 :: [])))> : <int list >


Alpha Renaming of bound variables

-| fun f y = <fn x => x + ~y>;

val f = fn : <int> -> <int -> int>

-| <fn x => 4 - ~(f <x>) 3>;

val it =

<(fn a => 4 %- ((fn b => b %+ a)) 3)>

: <int -> int>


Synopsis Annotations notation pronounced purpose

metaOCaml

< _ > brackets (build code) .< _ >.

~ _ escape (splice in code) .~ _

lift _ lift (turn values into code) ??

run _ run (execute runtime code) .! _


Synopsis MetaML features Pattern based object code templatestemplates “look like” the object language

Object-code has a type.The type of code is embedded in the meta-lang type system

Object code has structure.Possible to analyze it, take it apart, etc. (future lecture)

Automatic alpha-renaming of bound variables No name clashes

Object-code can be run or executed (runtime code-gen.)

Object-code can be observed (pretty-printed)


Example staged program-| fun copies 0 x = <[]>

| copies n x =

< ~x :: ~(copies (n-1) x)>;

val copies =

Fn : ['a].int -> <'a > -> <'a list>

-| copies 3 <3>;

val it = <[3,3,3]> : <int list>


Using MetamlFinding the installed image

/usr/local/bin/metaml ?? If you installed it on your machine look there

You should be able to type metaml and it should work

Caution - it may take a few seconds or so to start up

You may type functions and declarations at top level, or use the use function to load functions from a file. Keep a copy of your functions in a file and edit them separately from the command loop. In the command loop end a command with “;”


Usual ModeEdit window “XX.mml” MetaML Interaction Window

val y = <5>;

fun f x = <x + ~y>;

val ans = run (f 3);

-| use "XX.mml";

val y = <5> : <int>

val f = fn : int -> <int>

val ans = 8 : int

val it = () : unit

-|


Using MetaOcaml113 adara.cs.pdx.edu> pwd/u/sheard114 adara.cs.pdx.edu> bin/bin/metaocaml MetaOCaml version 3.08.0 alpha 015

# 3;;- : int = 3# .< 3 >.;;- : ('a, int) code = .<3>.# ^D115 adara.cs.pdx.edu>

Path, different on different

computers

Control “D” exits metaocal

/pkgs/metaocaml/current/bin/metaocaml


MetaOcaml Command line arguments

#quit ;; quit from the toplevel interaction#directory directory ;; add the directory to the search path#cd directory ;; change the working directory#load object_file ;; load an object file (.cmo)#use source_file ;; compile and load a source file#print_depth depth ;; modify the depth of printing#print_length width ;; modify the length of printing#install_printer function ;; specify a printing function#remove_printer function ;; remove a printing function#trace function ;; trace the arguments of the function#untrace function ;; stop tracing the functio#untrace_all ;; stop all tracing

All commands start with a “#”


Example of MetaOcaml Use

MetaOCaml version 3.08.0 alpha 015

# #cd "D:/work/sheard/Courses/StagedComp/web/notes" ;;# #use "xx.ml" ;;val y : ('a, int) code = .<5>.val f : int -> ('a, int) code = <fun>val ans : int = 8#

let y = .< 5 >. ;;let f x = .< x + .~ y >. ;;let ans = .! (f 3) ;;

File xx.ml

Toplevel interaction


Manuals and tutorials for Ocaml

Just normal Ocaml manual http://caml.inria.fr/oreilly-book Good for the basics of how Ocaml works

Tutorial http://www.metaocaml.org/doc/Tutorial%202004.pdf Lots of examples in MetaOcaml format

Gentle Introduction http://www.cs.rice.edu/~taha/publications/journal/dspg04a.pdf

All these links can be found on the metaocaml page

http://www.metaocaml.org/

http://caml.inria.fr/oreilly-book

http://www.cs.rice.edu/~taha/publications/journal/dspg04a.pdf


MetaML “features”

Useful functions-| pwd;val it = fn :unit ->

string

-| cd;val it = fn :string ->

unit

-| use;val it = fn :string ->

unit

-| feature;val it = fn :int -> bool

Other features

-| if 4 '<' 5 then 1 else 2;

val it = 1 : int

-| if 4'>' 5 then 1 else 2;

val it = 2 : int

-| #"a";

val it = #"a" : char

Note the use of quotes (‘) around the less than, and

greater than operators. Avoids ambiguity with staging

annotations


data List a = Nil | Cons a (list a)

map f Nil = Nilmap f (Cons x xs)= (f x):(map f xs)

pi = 3.14159

\ x -> x + 1

even 0 = Trueeven n = odd (n-1)odd 1 = Trueodd n = even n-1

code = [| 3 + 4 |]

-- No run in -- Template Haskell

datatype ‘a list = Nil | Cons of ‘a*(‘a list)

fun map f Nil = Nil | map f (Cons(x,xs)) = (f x)::(map f xs)

val pi = 3.14159

fn x => x + 1

fun even 0 = true | even n = odd (n-1)and odd 1 = true | odd n = even (n-1)

val code = < 3 + 4 >;

val ans = run code

Differences between

type ‘a list = Nil | Cons of ‘a*(‘a list)

let rec map f x = match x with Nil -> Nil | Cons(x,xs) -> (f x)::(map f xs)

let pi = 3.14159

function x -> x + 1

let rec even x = match x with 0 -> true | n -> odd (n-1) and odd x = match x with 1 -> true | n = even (n-1)

let code = .< 3 + 4 >. ;;

Let ans = .! code

Template Haskell,

MetaMl MetaOcaml


Staging Anomalies

Correct use of variablesRun of open codeDynamically typed programs


Correct use of staged variables

Each variable is declared at some level-| fn x => <fn y => <fn z => z + x + y>>;val it = fn: int -> <int -> <int -> int>><fn x => ~((fn y => <y>) 3)> What level is each variable bound at?

A variable can legally be accessed at a level greater or equal to the level of its declaration.-| <fn x => ~(copies x <1>)>;Error: The term: xin file 'top level' 20 - 21variable bound in phase 1 used too early in phase 0

Run of open code-| <fn x => ~(run <x>)>;

Error: In the dynamic runtime environment: Variable Not Found: 'x'617‘


Dynamic typingfun k 0 x = x | k n x = <fn x => ~(k (n-1) <x>)>

K 0 <1> <1>K 1 <1> <fn x => 1>K 2 <1> -> <fn x => fn y => 1>K 3 <1> -> <fn x => fn y => fn z => 1>

But look what happens

-| fun k 0 x = x | k n x = <fn x => ~(k (n-1) <x>)>;Error: The term:Cannot unify the types: occurs check a'618 and a'618 -> a'618 in expression: <(fn x => ~k (n - 1) (<x>))>


Code level optimizationsMetaML performs optimizations on code when the code is performed. It performs only those optimizations that are guaranteed not to make the code larger, and guaranteed not to change the termination of the code.

-| feature 0;

1 Safe-beta is off.

2 Safe-eta is on.

3 Let-hoisting is on.

4 Monad-law-normalization is on.

val it = false : bool


Safe Beta-| <(fn x => (fn y => x+y) 5)>;

val it =

<(fn a => ((fn b => a %+ b)) 5)>

: <int -> int>

-| feature 1;

Safe-beta is on.

val it = true : bool

-| <(fn x => (fn y => x+y) 5)>;

val it =

<(fn a => a %+ 5)>

: <int -> int>

Compare!


When Beta is not safe

-| feature 1;

Safe-beta is on.


-| <(fn x => x + x) (3+4)>;

val it =

<((fn a => a %+ a)) (3 %+ 4)> : <int>

-| <(fn x => x + x) 6>;

val it = <6 %+ 6> : <int>

Duplication could make

code bigger, or duplicate effects

Constants never make code

grow, or have effects


Safe eta-| <fn f => fn x => f x>;

val it = <(fn a => (fn b => a b))>

: ['a,'b].<('b -> 'a ) -> 'b -> 'a >

-| feature 2;

Safe-eta is on.


-| <fn f => fn x => f x>;

val it = <(fn a => a)>

: ['a,'b].<('b -> 'a ) -> 'b -> 'a >


When eta is not safe

-| <fn x => append [2] x>;

val it =

<(fn a => %append ([2]) a)>

: <int list -> int list>

-| <fn x => append x x>;

val it = <(fn a => %append a a)>

: ['a].<'a list -> 'a list>

You might expect <append [2]>

But this could have side effect, and

<fn x => append [2] x>Won’t have side effect

until called.

You might expect <append a>

But then a escapes it’s binding site


Let normalization-| <let val x = (let val y = 5 in y + 2 end) in x - 7 end>;val it = <let val a = 5 val b = a %+ 2 in b %- 7 end> : <int>

-| feature 3;Let-hoisting is off.val it = false : bool

-| <let val x = (let val y = 5 in y + 2 end) in x - 7 end>;val it = <let val a = (let val b = 5 in b %+ 2 end) in a %- 7 end> : <int>

-|


Object Level OptimizationsOptimizations may or may not apply depending upon whether they might change the semantics of the object program.The “feature” control allows user to turn them on and off.If they do apply, the optimized object program will always behave the same.The optimized object program will be smaller, or look “prettier”.

tim sheard oregon graduate institute

Documents

good paper

paper presentationpresentation

paper interesting

partswhat kind of paper

paper isnt necessary

new contexts

new idea

whats new