Paradigmer i Programmering 4

Resten af ML -Læse fra/skrive til filer -Interaktive programmer -Separat oversættelse -Parsergeneratorer

Læse en fil fun readfile1 is = if TextIO.endOfStream is then (TextIO.closeIn is; []) else (TextIO.inputLine is)::(readfile1 is); fun readfile nm = readfile1 (TextIO.openIn nm); val lst = readfile "tst.sml"; quit();

Resultat Moscow ML version 2.00 (June 2000) Enter `quit();' to quit. [opening file "C:\mads\undvs\pip-f02\tst.sml"] > val readfile1 = fn : instream -> string list > val readfile = fn : string -> string list > val lst = ["fun readfile1 is = \n", " if TextIO.endOfStream is \n", " then (TextIO.closeIn is; [])\n", " else (TextIO.inputLine is)::(readfile1 is);\n", "fun readfile nm = \n", " readfile1 (TextIO.openIn nm);\n", "\n", "val fil=readfile \"tst.sml\";\n", "quit();\n", "\n", "\n"] : string list

Skrive til en fil fun writefile1 os [] = TextIO.closeOut os | writefile1 os (x::xs) = (TextIO.output(os,x) ; writefile1 os xs); fun writefile nm lst = writefile1 (TextIO.openOut nm) lst; writefile "tst1.sml" lst;

TextIO del-oversigt val stdIn = : instream val stdOut = : outstream val openIn = fn : string -> instream val openOut = fn : string -> outstream val openAppend = fn : string -> outstream val inputLine = fn : instream -> string val endOfStream = fn : instream -> bool val print = fn : string -> unit val output = fn : outstream * string -> unit val closeIn = fn : instream -> unit val closeOut = fn : outstream -> unit

printVal i fortolkeren - val x = ([1,2,3],"hej",true); > val x = ([1, 2, 3], "hej", true) : int list * string * bool - printVal x; ([1, 2, 3], "hej", true) > val it = ([1, 2, 3], "hej", true) : int list * string * bool printVal kan bruges for alle typer, men kan kun bruges i fortolkeren - ikke i et oversat program

Dialog fun rl() = TextIO.inputLine(TextIO.stdIn); fun wl x = (TextIO.output(TextIO.stdOut,x); TextIO.flushOut(TextIO.stdOut)); fun readtoblank () = let val ln = rl() in if ln="\n" then [ln] else ( wl ("læste : "^ln); ln::(readtoblank()) ) end; val x = readtoblank(); val y = quit();

Lidt mere generelt fun processtoexit f state = let val ln = (wl ”- ”;rl()) in if ln="exit\n" then state else processtoexit f (f ln state) end; fun ff ln state = val x = processtoexit ff []; ff : tekst -> tilstand -> tilstand hver linie inddata giver programmet en ny tilstand

Typer > val rl = fn : unit -> string > val wl = fn : string -> unit > val readtoblank = fn : unit -> string list > val 'a processtoexit = fn : (string -> 'a -> 'a) -> 'a -> 'a > val 'a ff = fn : 'a -> 'a list -> 'a list

mosmlc tst.sml C:\mads\undvs\pip-f03>mosmlc tst.sml C:\mads\undvs\pip-f03>mosmlout ghs - exit C:\mads\undvs\pip-f03>

Referencer val = ref lav reference til værdi ! hent værdi fra reference := ændre værdi af reference

Referencer - val x = ref [1]; > val x = ref [1] : int list ref - x := 2::(!x); > val it = () : unit - x; > val it = ref [2, 1] : int list ref - x := 3::(!x); > val it = () : unit - x; > val it = ref [3, 2, 1] : int list ref

Lommeregner program: Explist Explist: ε - ingenting | Exp ”;” Explist Exp: Number | ”(” Exp ”)” | Exp ”+”Exp | Exp ”-” Exp | Exp ”*” Exp | Exp ”/” Exp | Exp ”%” Exp

Struktur Leksikalsk analyse: inddatastrøm -> buffer -> terminalsymbol Syntaksanalyse (buffer -> terminalsymbol) -> syntakstræ Semantisk analyse: syntakstræ -> uddata Hovedprogram: filnavn -> uddata semantik ( syntaks ( leksikalsk(openIn filnavn))))

Oversættelse mosmllex Exlex.lexgenerer Exlex.sml mosmlyac -v Expar.grmgenerer Expar.sml mosmlc -c Absyn.sml oversæt abstr. syntaks mosmlc -c -liberal Expar.sig Expar.sml parser mosmlc -c Exlex.sml leksikalsk analysator mosmlc -o Main.exe Main.sml hovedprogram Main test.txt testkørsel

Abstrakt syntaks datatype exp = Const of int | Binop of string * exp * exp;

YACC fil (del 1) %{ open Absyn; %} %token NUMBER %token STRING NAME %token MAX MIN PLUS MINUS TIMES DIV MOD %token LPAR RPAR SEMI COMMA EOF %left PLUS MINUS %left TIMES DIV MOD %start Main %type Main Explist %type Exp %

YACC fil (del 2) Main: Explist EOF { $1 } ; Explist: /* empty */ { [] } | Exp SEMI Explist { $1 :: $3 } ; Exp: NUMBER { Const $1 } | LPAR Exp RPAR { $2 } | Exp PLUS Exp { Binop("+", $1, $3) } | Exp MINUS Exp { Binop("-", $1, $3) } | Exp TIMES Exp { Binop("*", $1, $3) } | Exp DIV Exp { Binop("/", $1, $3) } | Exp MOD Exp { Binop("%", $1, $3) } ;

Lex fil (del 1) { open Lexing Expar; exception LexicalError; fun keyword s = case s of "max" => MAX | "min" => MIN | _ => NAME s; (* bruges ikke her *) }

Lex fil (del 2) rule Token = parse [` ` `\t` `\n` `\r`] { Token lexbuf } | [`0`-`9`]+ { NUMBER (Option.valOf (Int.fromString (getLexeme lexbuf))) } | [`a`-`z``A`-`Z`][`a`-`z``A`-`Z``0`-`9`]* { keyword (getLexeme lexbuf) } | `+` { PLUS } | `-` { MINUS } | `*` { TIMES } | `/` { DIV } | `%` { MOD } | `(` { LPAR } | `)` { RPAR } | `;` { SEMI } | `,` { COMMA } | "/*" { SkipComment lexbuf; Token lexbuf } | eof { EOF } | _ { raise LexicalError } and SkipComment = parse "*/" { () } | (eof | `\^Z`) { raise LexicalError } | _ { SkipComment lexbuf } ;

Main (del 1) open Absyn; (* den abstrakte syntaks *) fun eval (Const n) = n | eval (Binop("+",e1,e2))= (eval e1)+(eval e2) | eval (Binop("-",e1,e2)) = (eval e1)-(eval e2) | eval (Binop("*",e1,e2)) = (eval e1)*(eval e2) | eval (Binop("/",e1,e2)) = (eval e1) div (eval e2) | eval (Binop("%",e1,e2)) = (eval e1) mod (eval e2) ; fun evalprint e = let val r = eval e in print ((Int.toString r)^"\n") end;

Main (del 2) fun createLexerStream ( is : BasicIO.instream ) = Lexing.createLexer ( fn buff => fn n => Nonstdio.buff_input is buff 0 n) fun compile filename = let val stream = BasicIO.open_in filename; val lexbuf = createLexerStream stream; val elist = Expar.Main Exlex.Token lexbuf in app evalprint elist end handle Parsing.ParseError f => raise Fail "Syntactical error" | Exlex.LexicalError => raise Fail "Lexical error"; val _ = compile (List.nth(Mosml.argv (),1))

Udtryk konstanter parametre operationer og funktionskald (,, ) [,, ] raise handle if then else ( ; ; ) let ; ;.. in end case of fn

Operationer andalso, orelse (sprogkonstruktioner) + - * div mod = <> >= > <= < ^ o before f.eks (3 before print ”hej”) udskriv ”hej” og returner 3

, match ::= mrule { ”|” mrule } mrule ::= pat ”=>” exp dec ::= ”val” pat ”=” exp { ”and” pat ”=” exp} | ”fun” nm pat-list = exp |... ”and”... | ”datatype”.. | ”exception”.. | ”local” dec ”in” dec ”end” | ”infix”...

case udtryk - fun myapp [] ys = ys | myapp (x::xs) ys = x::(myapp xs ys); > val 'a myapp = fn : 'a list -> 'a list -> 'a list - fun myapp xl yl = case xl of [] => yl | (x::xs) => x::(myapp xs yl); > val 'a myapp = fn : 'a list -> 'a list -> 'a list

Hvad mere -Records -Structure, signature, functor -Separat oversættelse -Interface til C, databaser, cgi, socket -Principperne for typecheck

Hvorfor ML ”what is it good for?” Styrker – kompleks, videnstung programstil Godt for den stærke programmør Komplekse systemer udtrykkes kompakt Svaghed – kræver god abstraktionsevne Tungt til interaktive programmer - grafik