FYP Final Presentation

  • 276 views
Uploaded on

 

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
276
On Slideshare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
0
Comments
0
Likes
0

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. OCaml Language Extensions and Abstractions
  • 2. PROJECT OBJECTIVES
  • 3. DEBUGGING EXTENSION
  • 4. LAZY EVALUATION EXTENSION
  • 5. WHAT IS CAMLP4?
  • 6. WHAT IS CAMLP4? Caml Preprocessor and Pretty Printer
  • 7. let  rec  fib  =      |  0  -­‐>  0      |  1  -­‐>  1      |  n  when  n  >  1  -­‐>          fib  (n  -­‐  1)  +  fib  (n  -­‐  2)    
  • 8. let  rec  fib  =  memo      |  0  -­‐>  0      |  1  -­‐>  1      |  n  when  n  >  1  -­‐>          fib  (n  -­‐  1)  +  fib  (n  -­‐  2)    
  • 9. let  rec  fib  =      let  tbl  =  Hashtbl.create  100  in      fun  x  -­‐>          try  Hashtbl.find  tbl  x          with  Not_found  -­‐>              let  result  =                  match  x  with                  |  0  -­‐>  0                  |  1  -­‐>  1                  |  n  when  n  >  1  -­‐>                      fib  (n  -­‐  1)  +  fib  (n  -­‐  2)  in              do  {  Hashtbl.replace  tbl  x  result;                        ;result  }  
  • 10. let  rec  fib  =      let  tbl  =  Hashtbl.create  100  in      fun  x  -­‐>          try  Hashtbl.find  tbl  x          with  Not_found  -­‐>              let  result  =                  match  x  with                  |  0  -­‐>  0                  |  1  -­‐>  1                  |  n  when  n  >  1  -­‐>                      fib  (n  -­‐  1)  +  fib  (n  -­‐  2)  in              do  {  Hashtbl.replace  tbl  x  result;                        ;result  }  
  • 11. THINK MACROS
  • 12. C MACROS?
  • 13. LISP MACROS For a statically typed language
  • 14. let  simple_optimize  =      object          inherit  Ast.map  as  super          method  expr  e  =              match  super#expr  e  with              |  <:expr<  1  *  $e$  >>  -­‐>                    <:expr<  $e$  >>              |  <:expr<  0  +  $e$  >>  -­‐>                    <:expr<  $e$  >>                                            |  e  -­‐>  e                                                   end  
  • 15. let  simple_optimize  =      object          inherit  Ast.map  as  super          method  expr  e  =              match  super#expr  e  with              |  <:expr<  1  *  $e$  >>  -­‐>                    <:expr<  $e$  >>              |  <:expr<  0  +  $e$  >>  -­‐>                    <:expr<  $e$  >>                                            |  e  -­‐>  e                                                   end  
  • 16. let  simple_optimize  =   1  *  humblepi  BECOMES  humblepi      object   0  +  humblepi  BECOMES  humblepi          inherit  Ast.map  as  super          method  expr  e  =              match  super#expr  e  with              |  <:expr<  1  *  $e$  >>  -­‐>                    <:expr<  $e$  >>              |  <:expr<  0  +  $e$  >>  -­‐>                    <:expr<  $e$  >>                                            |  e  -­‐>  e                                                   end  
  • 17. DEBUGGING EXTENSION Easier function tracing and debugging using annotations
  • 18. PROBLEM Functions are hard to debug
  • 19. type  env  =  (string  *  expr)  list   and   expr  =      |  Var  of  string      |  IntConst  of  int      |  Plus  of  expr  *  expr      |  Minus  of  expr  *  expr      |  Lambda  of  string  *  expr      |  Apply  of  expr  *  expr      |  Closure  of  env  *  string  *  expr  
  • 20. let  rec  eval  env  e  =      let  rec  aux  env  e  =          match  e  with          |  IntConst  _  -­‐>  e          |  Plus  (e1,  e2)  -­‐>            ...  in      aux  env  e  
  • 21. NO GENERIC PRINTERS
  • 22. let rec string_of_expr e =! match e with! ... (* for every variant *)! and string_of_env env =! (* Map string_of_expr over elements *)!
  • 23. let  rec  eval  env  e  =      let  rec  aux  env  e  =          match  e  with          |  IntConst  _  -­‐>  e          |  Plus  (e1,  e2)  -­‐>            …  in      let  _  =  printf  "Input:  env  =  %s,  e  =  %s"   (string_of_env  env)  (string_of_expr  e)  in      let  out  =  aux  env  e  in      let  _  =  printf  "Output:  %s"  (string_of_expr  e)   in  out      
  • 24. let  rec  eval  env  e  =      let  rec  aux  env  e  =          match  e  with          |  IntConst  _  -­‐>  e          |  Plus  (e1,  e2)  -­‐>            …  in      let  _  =  printf  "Input:  env  =  %s,  e  =  %s"   (string_of_env  env)  (string_of_expr  e)  in      let  out  =  aux  env  e  in      let  _  =  printf  "Output:  %s"  (string_of_expr  e)   in  out      
  • 25. let  rec  eval  env  e  =      let  rec  aux  env  e  =          match  e  with          |  IntConst  _  -­‐>  e          |  Plus  (e1,  e2)  -­‐>   and Cumbersome Tedious          …  in      let  _  =  printf  "Input:  env  =  %s,  e  =  %s"   (string_of_env  env)  (string_of_expr  e)  in      let  out  =  aux  env  e  in      let  _  =  printf  "Output:  %s"  (string_of_expr  e)   in  out      
  • 26. SOLUTION Generate debugging code from function annotated with debug keyword
  • 27. let  rec  eval  env  e  =      let  rec  aux  env  e  =          match  e  with          |  IntConst  _  -­‐>  e          |  Plus  (e1,  e2)  -­‐>            ...  in      aux  env  e  
  • 28. let  debug  rec  eval  env  e  =      let  rec  aux  env  e  =          match  e  with          |  IntConst  _  -­‐>  e          |  Plus  (e1,  e2)  -­‐>            ...  in      aux  env  e  
  • 29. DEMO
  • 30. HOW DOES IT WORK?
  • 31. Annotated Expression
  • 32. Annotated Expression Camlp4 Lexer & Parser
  • 33. Annotated Expression Camlp4 Lexer & Parser Type Inference
  • 34. Annotated Expression Camlp4 Lexer & Parser Type Inference Deriving Library
  • 35. Annotated Expression Camlp4 Lexer & Parser Type Inference Deriving Library AST Transformer
  • 36. Annotated Expression Camlp4 Lexer & Parser Type Inference Deriving Library AST Transformer Generated OCaml Code
  • 37. Annotated Expression Camlp4 Lexer & Parser Type Inference Deriving Library AST Transformer Generated OCaml Code
  • 38. Annotated Expression Camlp4 Lexer & Parser Type Inference Deriving Library AST Transformer Generated OCaml Code
  • 39. TYPE INFERENCE
  • 40. let sqr x = x * x! TYPE INFERENCE STEP RETURNS [“int”; “int”]!
  • 41. let fact count x =
 match x with
 | 1 -> x
 | n -> fact (count – 1) (n * x)! 

  • 42. let fact count x =
 match x with
 | 1 -> x
 | n -> fact (count – 1) (n * x)! TYPE INFERENCE STEP RETURNS [“int”; “int”; “int”]! 

  • 43. Annotated Expression Camlp4 Lexer & Parser Type Inference Deriving Library AST Transformer Generated OCaml Code
  • 44. DERIVING LIBRARY Third party open source library that generates printing functions from types
  • 45. type  env  =  (string  *  expr)  list   and   expr  =      |  Var  of  string      |  IntConst  of  int      |  Plus  of  expr  *  expr      |  Minus  of  expr  *  expr      |  Lambda  of  string  *  expr      |  Apply  of  expr  *  expr      |  Closure  of  env  *  string  *  expr      deriving  (Show)  
  • 46. Show.show<expr>  (Plus  (IntConst  40)                                                  (IntConst  2))  
  • 47. LAZY EVALUATION EXTENSION Automatic generation of lazy and force
  • 48. PROBLEM Lazy streams are difficult to work with
  • 49. type 'a node_t =
 | Nil
 | Cons of 'a *
 ('a node_t)!
  • 50. type 'a node_t =
 | Nil
 | Cons of 'a *
 ('a node_t) Lazy.t!
  • 51. let map f l =
 let rec aux rest =
 match Lazy.force rest with
 | Cons (x, r) ->
 Cons (f x, lazy (aux r))
 | Nil ->
 Nil in
 lazy (aux l)!
  • 52. let map f l =
 let rec aux rest =
 match Lazy.force rest with
 | Cons (x, r) ->
 Cons (f x, lazy (aux r))
 | Nil ->
 Nil in
 lazy (aux l)!
  • 53. let zipwith f l1 l2 =
 let rec aux r1 r2 =
 match Lazy.force r1, Lazy.force r2 with
 | Cons (x1, r1), Cons (x2, r2) ->
 Cons ((f x1 x2), lazy (aux r1 r2))
 | Cons (x, r), Nil ->
 Cons (x, lazy (aux r (lazy Nil)))
 | Nil, Cons (x, r) ->
 Cons (x, lazy (aux (lazy Nil) r))
 | Nil, Nil -> Nil in
 lazy (aux l1 l2)!
  • 54. let zipwith f l1 l2 =
 let rec aux r1 r2 =
 match Lazy.force r1, Lazy.force r2 with
 | Cons (x1, r1), Cons (x2, r2) ->
 Cons ((f x1 x2), lazy (aux r1 r2))
 | Cons (x, r), Nil ->
 Cons (x, lazy (aux r (lazy Nil)))
 | Nil, Cons (x, r) ->
 Cons (x, lazy (aux (lazy Nil) r))
 | Nil, Nil -> Nil in
 lazy (aux l1 l2)!
  • 55. SOLUTION Annotate with keyword and insert lazy and force when type error occurs
  • 56. let ilazy map f l =
 let rec aux rest =
 match rest with
 | Cons (x, r) ->
 Cons (f x, aux r)
 | Nil ->
 Nil in
 aux l!
  • 57. let ilazy zipwith f l1 l2 =
 let rec aux r1 r2 =
 match r1, r2 with
 | Cons (x1, r1), Cons (x2, r2) ->
 Cons ((f x1 x2), (aux r1 r2))
 | Cons (x, r), Nil ->
 Cons (x, (aux r Nil))
 | Nil, Cons (x, r) ->
 Cons (x, (aux Nil r))
 | Nil, Nil -> Nil in
 (aux l1 l2)!
  • 58. HOW DOES IT WORK?
  • 59. Annotated Expression
  • 60. Annotated Expression Camlp4 Lexer & Parser
  • 61. Annotated Expression Camlp4 Lexer & Parser Type Checker
  • 62. Annotated Expression Camlp4 Lexer & Parser Type Checker AST Transformer
  • 63. Annotated Expression Camlp4 Lexer & Parser Type Checker AST Transformer Generated OCaml Code
  • 64. Annotated Expression Camlp4 Lexer & Parser Type Checker AST Transformer Generated OCaml Code
  • 65. TYPE CHECKER OUTPUT
  • 66. Error: This expression has type 'a lazy_t! but an expression was expected of type! 'b Batteries.LazyList.node_t = 'b BatLazyList.node_t!
  • 67. Error: This expression has type 'a lazy_t! but an expression was expected of type! 'b node_t! THIS SAYS INSERT Lazy.force!
  • 68. Error: This expression has type! 'a node_t! but an expression was expected of type! ! ! !int node_t lazy_t!
  • 69. Error: This expression has type! 'a node_t! but an expression was expected of type! ! ! !int node_t lazy_t! THIS SAYS INSERT lazy!
  • 70. TYPE CHECKER OUTPUT Output is in the form of a typed tree
  • 71. TECHNICAL CHALLENGES
  • 72. UNFAMILIARITY WITH LANGUAGE Lots of mucking around
  • 73. OPEN in most OO languages RECURSION A feature
  • 74. let  insert_lazy_at  loc  =      object          inherit  Ast.map  as  super          method  expr  e  =              match  super#expr  e  with              |  <:expr@_loc<  $e1$  $e2$  >>                        when  _loc  =  loc  -­‐>                    <:expr<  lazy  ($e1$  $e2$)  >>              |  <:expr@_loc<  $id:i$  >>                        when  _loc  =  loc  -­‐>                    <:expr<  lazy  $id:i$  >>              |  e  -­‐>  e     end  
  • 75. LACK OF DOCUMENTATION Lots of code reading
  • 76. ASKING QUESTIONS ON IRC
  • 77. SEARCHING AND READING COMPILER SOURCE CODE
  • 78. QUESTIONS?