1 / 16

Fundamentals of Staged Computation Lecture 6: Monadic Staging of RE Language

Learn about Monadic Staging of the RE language in this informative lecture. Assignments posted on the webpage. Due Feb 1, 2005. Reading material provided. Dive into Staging Algebraic Datatypes by Tim Sheard and Iavor Diatchki.

jenn
Download Presentation

Fundamentals of Staged Computation Lecture 6: Monadic Staging of RE Language

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Fundamentals of Staged Computation Tim Sheard Oregon Graduate Institute Lecture 6: Monadic Staging of the RE language CSE 510 Section FSC Winter 2004

  2. Assignments • Assignment 4 is now posted on webpage • Due in 1 week on Feb 1, 2005 • Reading Assignment now on webpage • Staging Algebraic Datatypes • By Tim Sheard and Iavor Diatchki • Must be read by next Tueday Feb. 1 • Volunteers for presentation? Cs510 FSC Winter 2005

  3. Recall RE Language datatype 'a Maybe = Just of 'a | Nothing; datatype RE = Lit of string | Or of (RE*RE) | Concat of (RE*RE) | Star of RE; fun prefix [] xs = Just xs | prefix (y::ys) (x::xs) = if y=x then prefix ys xs else Nothing | prefix ys xs = Nothing; Cs510 FSC Winter 2005

  4. One interpreter fun eval (Lit s) input = (case prefix (explode s) input of Just more => Just(s,more) | Nothing => Nothing) | eval (Or(a,b)) input = (case eval a input of Nothing => eval b input | Just pair => Just pair) | eval (Concat(a,b)) input = (case (eval a input) of Just(zs,rest) => (case eval b rest of Just (bs,more) => Just (zs ^ bs,more) | Nothing => Nothing) | Nothing => Nothing) | eval (Star x) input = let fun f input = case eval x input of Nothing => ("",input) | Just (cs,zs) => let val (bs,ws) = f zs in (cs ^ bs,ws) end in Just(f input) end; Cs510 FSC Winter 2005

  5. Staging it fun Seval (Lit s) input = <case prefix (explode ~(lift s)) ~input of Just more => Just(~(lift s),more) | Nothing => Nothing> | Seval (Or(a,b)) input = <case ~(Seval a input) of Nothing => ~(Seval b input) | Just pair => Just pair> | Seval (Concat(a,b)) input = <case ~(Seval a input) of Just(zs,rest) => (case ~(Seval b <rest>) of Just (bs,more) => Just (zs ^ bs,more) | Nothing => Nothing) | Nothing => Nothing> Cs510 FSC Winter 2005

  6. Staging continued Note how the helper function “f” is in the generated code. | Seval (Star x) input = <let fun f input = case ~(Seval x <input>) Nothing => ("",input) | Just (cs,zs) => let val (bs,ws) = f zs in (cs ^ bs,ws) end in Just(f ~input) end>; Cs510 FSC Winter 2005

  7. What does it generate? val t1 = Concat(Or(Lit "tim",Lit "mary") ,Star (Lit "x")); fun test x = <fn s => ~(Seval x <s>)>; fun f x = (run(test t1)) (explode x); test t1; Cs510 FSC Winter 2005

  8. -| test t1; val it = <(fn a => (case (case (case %prefix (%explode "tim") a of Just o => Just("tim",o) | Nothing => Nothing) of Nothing => (case %prefix (%explode "mary") a of Just n => Just("mary",n) | Nothing => Nothing) | Just m => Just m) of Just(c,b) => (case let fun f g = (case (case %prefix (%explode "x") g of Just l => Just("x",l) | Nothing => Nothing) of Nothing => ("",g) | Just(i,h) => let val (k,j) = f h in (i %^ k,j) end) in Just (f b) end of Just(e,d) => Just(c %^ e,d) | Nothing => Nothing) | Nothing => Nothing))> : <char list -> (string * char list) Maybe> Cs510 FSC Winter 2005

  9. Monadic version <Do %mm { a <- %try (%prefix2 (%explode "tim")) (%prefix2 (%explode "mary")) ; b <- %star (%prefix2 (%explode "x")) ; Return %mm (a %@ %concat b) }> : <char list M> • What is the Monad used here? Cs510 FSC Winter 2005

  10. The “meaning” type Eval :: RE -> char list -> (string * char list) Maybe datatype 'a M = M of (char list -> ('a* char list) Maybe); fun unM (M x) = x; • Eval2 :: RE -> char list M Cs510 FSC Winter 2005

  11. Implementing the Monad val mm = let fun return x = M (fn s => Just(x,s)); fun bind (M f) g = let fun h s = case f s of Just(a,s2) => unM (g a) s2 | Nothing => Nothing in M h end in Mon(return,bind) end; Cs510 FSC Winter 2005

  12. Operations on the monad fun test (M f) = let fun h s = case f s of Nothing => Just(Nothing,s) | Just(a,rest) => Just(Just a,rest) in M h end; fun prefix2 s = let fun h x = case prefix s x of Nothing => Nothing | Just m => Just(s,m) in M h end; fun try (M f) (M g) = let fun h s = case f s of Nothing => g s | Just pair => Just pair in M h end Cs510 FSC Winter 2005

  13. Monadic Version fun star m = Do mm { mx <- test m ; case mx of Just x => Do mm { xs <- star m ; Return mm (x::xs) } | Nothing => Return mm []}; fun eval2 (Lit s) = prefix2 (explode s) | eval2 (Or(a,b)) = try (eval2 a) (eval2 b) | eval2 (Concat(a,b)) = Do mm { x <- eval2 a ; y <- eval2 b ; Return mm (x@y)} | eval2 (Star x) = Do mm { xss <- star (eval2 x) ; Return mm (concat xss) } Cs510 FSC Winter 2005

  14. Staged Monadic Version fun Seval2 (Lit s) = <prefix2 (explode ~(lift s))> | Seval2 (Or(a,b)) = <try ~(Seval2 a) ~(Seval2 b)> | Seval2 (Concat(a,b)) = <Do mm { x <- ~(Seval2 a) ; y <- ~(Seval2 b) ; Return mm (x@y)}> | Seval2 (Star x) = <Do mm { xss <- star ~(Seval2 x) ; Return mm (concat xss) }>; Cs510 FSC Winter 2005

  15. Results -| Seval2 t1; val it = <Do %mm { a <- %try (%prefix2 (%explode "tim")) (%prefix2 (%explode "mary")) ; b <- %star (%prefix2 (%explode "x")) ; Return %mm (a %@ %concat b) }> : <char list M> Note calls to the monadic operators “try”, “star”, “test” (embedded in call to “star”), and “prefix2” Cs510 FSC Winter 2005

  16. Cs510 FSC Winter 2005

More Related