FYP Final Presentation

569 views

Published on

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
569
On SlideShare
0
From Embeds
0
Number of Embeds
3
Actions
Shares
0
Downloads
4
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

FYP Final Presentation

  1. 1. OCaml Language Extensions and Abstractions
  2. 2. PROJECT OBJECTIVES
  3. 3. DEBUGGING EXTENSION
  4. 4. LAZY EVALUATION EXTENSION
  5. 5. WHAT IS CAMLP4?
  6. 6. WHAT IS CAMLP4? Caml Preprocessor and Pretty Printer
  7. 7. let  rec  fib  =      |  0  -­‐>  0      |  1  -­‐>  1      |  n  when  n  >  1  -­‐>          fib  (n  -­‐  1)  +  fib  (n  -­‐  2)    
  8. 8. let  rec  fib  =  memo      |  0  -­‐>  0      |  1  -­‐>  1      |  n  when  n  >  1  -­‐>          fib  (n  -­‐  1)  +  fib  (n  -­‐  2)    
  9. 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. 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. 11. THINK MACROS
  12. 12. C MACROS?
  13. 13. LISP MACROS For a statically typed language
  14. 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. 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. 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. 17. DEBUGGING EXTENSION Easier function tracing and debugging using annotations
  18. 18. PROBLEM Functions are hard to debug
  19. 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. 20. let  rec  eval  env  e  =      let  rec  aux  env  e  =          match  e  with          |  IntConst  _  -­‐>  e          |  Plus  (e1,  e2)  -­‐>            ...  in      aux  env  e  
  21. 21. NO GENERIC PRINTERS
  22. 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. 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. 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. 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. 26. SOLUTION Generate debugging code from function annotated with debug keyword
  27. 27. let  rec  eval  env  e  =      let  rec  aux  env  e  =          match  e  with          |  IntConst  _  -­‐>  e          |  Plus  (e1,  e2)  -­‐>            ...  in      aux  env  e  
  28. 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. 29. DEMO
  30. 30. HOW DOES IT WORK?
  31. 31. Annotated Expression
  32. 32. Annotated Expression Camlp4 Lexer & Parser
  33. 33. Annotated Expression Camlp4 Lexer & Parser Type Inference
  34. 34. Annotated Expression Camlp4 Lexer & Parser Type Inference Deriving Library
  35. 35. Annotated Expression Camlp4 Lexer & Parser Type Inference Deriving Library AST Transformer
  36. 36. Annotated Expression Camlp4 Lexer & Parser Type Inference Deriving Library AST Transformer Generated OCaml Code
  37. 37. Annotated Expression Camlp4 Lexer & Parser Type Inference Deriving Library AST Transformer Generated OCaml Code
  38. 38. Annotated Expression Camlp4 Lexer & Parser Type Inference Deriving Library AST Transformer Generated OCaml Code
  39. 39. TYPE INFERENCE
  40. 40. let sqr x = x * x! TYPE INFERENCE STEP RETURNS [“int”; “int”]!
  41. 41. let fact count x =
 match x with
 | 1 -> x
 | n -> fact (count – 1) (n * x)! 

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

  43. 43. Annotated Expression Camlp4 Lexer & Parser Type Inference Deriving Library AST Transformer Generated OCaml Code
  44. 44. DERIVING LIBRARY Third party open source library that generates printing functions from types
  45. 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. 46. Show.show<expr>  (Plus  (IntConst  40)                                                  (IntConst  2))  
  47. 47. LAZY EVALUATION EXTENSION Automatic generation of lazy and force
  48. 48. PROBLEM Lazy streams are difficult to work with
  49. 49. type 'a node_t =
 | Nil
 | Cons of 'a *
 ('a node_t)!
  50. 50. type 'a node_t =
 | Nil
 | Cons of 'a *
 ('a node_t) Lazy.t!
  51. 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. 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. 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. 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. 55. SOLUTION Annotate with keyword and insert lazy and force when type error occurs
  56. 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. 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. 58. HOW DOES IT WORK?
  59. 59. Annotated Expression
  60. 60. Annotated Expression Camlp4 Lexer & Parser
  61. 61. Annotated Expression Camlp4 Lexer & Parser Type Checker
  62. 62. Annotated Expression Camlp4 Lexer & Parser Type Checker AST Transformer
  63. 63. Annotated Expression Camlp4 Lexer & Parser Type Checker AST Transformer Generated OCaml Code
  64. 64. Annotated Expression Camlp4 Lexer & Parser Type Checker AST Transformer Generated OCaml Code
  65. 65. TYPE CHECKER OUTPUT
  66. 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. 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. 68. Error: This expression has type! 'a node_t! but an expression was expected of type! ! ! !int node_t lazy_t!
  69. 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. 70. TYPE CHECKER OUTPUT Output is in the form of a typed tree
  71. 71. TECHNICAL CHALLENGES
  72. 72. UNFAMILIARITY WITH LANGUAGE Lots of mucking around
  73. 73. OPEN in most OO languages RECURSION A feature
  74. 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. 75. LACK OF DOCUMENTATION Lots of code reading
  76. 76. ASKING QUESTIONS ON IRC
  77. 77. SEARCHING AND READING COMPILER SOURCE CODE
  78. 78. QUESTIONS?

×