1. 1 Aspectual Caml an Aspect-Oriented Functional Language Hideaki Tatsuzawa Hidehiko Masuhara Akinori Yonezawa University of Tokyo

2. 2 Background: Studies on AOPLs Practical languages are mostly based on OOPLs –Java [Kiczales et al. 2001] –C++ [Spinczyk et al. 2002] –etc. AOPLs based on functional languages are designed for theoretical purposes –MiniAML [Walker et al. 2003] –TinyAspect [Aldrich2004] –etc.

3. 3 Motivation Design and implement a functional AOPL Aspectual Caml by adopting advanced AOP features (e.g. inter-type declarations) for: –modularizing large functional programs compilers, theorem provers, etc. –providing a foundation of further theoretical studies under clear semantics of functional languages

4. 4 Contributions of Aspectual Caml Designed AspectJ-like AOP features in a functional language –pointcut-advice mechanism curried pointcuts type inference of aspects polymorphic and monomorphic pointcuts –type extension mechanism (cf. inter-type declarations in AspectJ) Showed an implementation framework

5. 5 aspect SubExtension type+ t =... | Sub of t * t advice eval_sub = [around (call eval env t)] match t with Sub(t1, t2)  let e = eval env in e t1 - e t2 | _  proceed t end aspect LogEval advice log_eval = [before (call eval _ _)] print_string “called eval\n” end type t = Add of t * t | Num of int | Let of string * t * t | Var of string let rec eval env t = match t with Add(t1, t2)  (eval env t1) + (eval env t2) | Num(i)  i | Let(s, t1, t2)  eval ((s, eval env t1)::env) t2 | Var(s)  List.assoc s env Motivating Example Simple Interpreter Aspects type declaration of terms function definition for evaluation of terms type extension extension of function behavior logging evaluation of terms

6. 6 Motivating Example type t = Add of t * t | Num of int | Let of string * t * t | Var of string let rec eval env t = match t with Add(t1, t2)  (eval env t1) + (eval env t2) | Num(i)  i | Let(s, t1, t2)  eval ((s, eval env t1)::env) t2 | Var(s)  List.assoc s env aspect SubExtension type+ t =... | Sub of t * t advice eval_sub = [around ( call eval env t )] match t with Sub(t1, t2)  let e = eval env in e t1 - e t2 | _  proceed t end Simple Interpreter Aspects aspect LogEval advice log_eval = [before (call eval _ _)] print_string “called eval\n” end extension of the type declaration specifies 2nd applications to function “eval”

7. 7 Required Features to Aspectual Caml 2 kinds of AOP features –Pointcut-advice mechanism –Type extension mechanism Type inference of aspects without base code –writing aspects without type annotations –ensuring type safety of woven code –enabling separate compilation

8. 8 Key Designs of Aspectual Caml Curried pointcuts Type extension mechanism Weaving with type inference 2 kinds of pointcuts –polymorphic and monomorphic

9. 9 Key Designs of Aspectual Caml Curried pointcuts Type extension mechanism Weaving with type inference 2 kinds of pointcuts –polymorphic and monomorphic Today’s main topic

10. 10 Curried Pointcuts Specify applications to curried functions easily –cover application to variables from the result of partial applications “call eval env t” specifies 2nd applications to “eval” “call eval env t” covers the application “e t” in the context of “let e = eval env in e t”

11. 11 Type Extension cf. inter-type declarations in AspectJ Constructor addition Field addition “type+ t = … | Sub t * t” adds the new constructor Sub that takes 2 arguments of the type t “type+ t = Var of … * int{0}” adds the new integer field to the constructor Var and “0” is the default value for the extra field

12. 12 Key Designs of Aspectual Caml Curried pointcuts Type extension mechanism Weaving with type inference –ensures type safety of woven code –allows to define pointcuts and advices without type annotations –checks type of aspects without base code cf. C++ templates 2 kinds of pointcuts –polymorphic and monomorphic

13. 13 Possible 2 Approaches for Type Safety Type checking woven code after weaving –no need of aspect typing –impossible separate compilations Type checking aspect code and base code before weaving –need of aspect typing –needed for separate compilations Weaving of Type Inference: Background

14. 14 Possible 2 Approaches for Type Safety Type checking woven code after weaving –no need of aspect typing –impossible separate compilations Type checking aspect code and base code before weaving –need of aspect typing –needed for separate compilations Our approach Weaving of Type Inference: Background

15. 15 Type System for Aspects Should deal with all kinds of declarations in aspects –pointcuts –advices –type extensions –local variables

16. 16 Example of Aspect Type Inference aspect SubExtension type t =... | Sub of t * t advice eval_sub = [around (call eval env t)] match t with Sub(t1, t2)  let e = eval env in e t1 - e t2 | _  proceed t end

17. 17 Type System for Aspects Should deal with all kinds of declarations in aspects –pointcuts infers types from explicitly specified types and kinds of pointcuts –advices –type extensions –local variables

18. 18 Type Inference of Pointcuts aspect SubExtension type t =... | Sub of t * t advice eval_sub = [around (call eval env t)] match t with Sub(t1, t2)  let e = eval env in e t1 - e t2 | _  proceed t end eval :α  β  γ env : α t : β does not use type information in base code (eval: (string * int) list  t  int)

19. 19 Type System for Aspects Should deal with all kinds of declarations in aspects –pointcuts –advices infers types of an advice body using extended environment with top-level variables of base code, variables bound by pointcuts, and “proceed” checks whether a type of an advice body match with one expected by contexts –type extensions –local variables

20. 20 Type Inference of “proceed” aspect SubExtension type t =... | Sub of t * t advice eval_sub = [around (call eval env t)] match t with Sub(t1, t2)  let e = eval env in e t1 - e t2 | _  proceed t end “proceed” means the continuation that takes the 2nd argument of “eval” and returns the result eval :α  β  γ env : α t : β proceed :  γ

21. 21 Type Inference of Advice Body aspect SubExtension type t =... | Sub of t * t advice eval_sub = [around (call eval env t)] match t with Sub(t1, t2)  let e = eval env in e t1 - e t2 | _  proceed t end infer the type of the advice body with the type environment extended with bound variables and “proceed” eval :α  β  γ env : α t : β proceed :  γ

22. 22 Type Inference of Advice Body aspect SubExtension type t =... | Sub of t * t advice eval_sub = [around (call eval env t)] match t with Sub(t1, t2)  let e = eval env in e t1 - e t2 | _  proceed t end eval :α  t  γ env : α t : t proceed : t  γ

23. 23 Type Inference of Advice Body aspect SubExtension type t =... | Sub of t * t advice eval_sub = [around (call eval env t)] match t with Sub(t1, t2)  let e = eval env in e t1 - e t2 | _  proceed t end eval :α  t  int env : α t : t proceed : t  int

24. 24 Checks Whether Type of Advice Body Matches Expected Type aspect SubExtension type t =... | Sub of t * t advice eval_sub = [around (call eval env t)] match t with Sub(t1, t2)  let e = eval env in e t1 - e t2 | _  proceed t end the expected type is the return type of “proceed”

25. 25 Checks Whether Type of Advice Body Matches Expected Type aspect SubExtension type t =... | Sub of t * t advice eval_sub = [around (call eval env t)] match t with Sub(t1, t2)  let e = eval env in e t1 - e t2 | _  proceed t end the expected type is the return type of “proceed” the type of advice body matches the expected type eval :α  t  int env : α t : t proceed : t  int

26. 26 Type System for Aspects Should deal with all kinds of declarations in aspects –pointcuts –advices –type extensions replaces corresponding information of type environment with the extended information –local variables

27. 27 Type Extension aspect SubExtension type t =... | Sub of t * t advice eval_sub = [around (call eval env t)] match t with Sub(t1, t2)  let e = eval env in e t1 - e t2 | _  proceed t end type t = Num of int | Add of t * t | Let of string * t * t | Var of string | Sub of t * t extends environment that is used in aspects

28. 28 Type System for Aspects Should deal with all kinds of declarations in aspects –pointcuts –advices –type extensions –local variables infers types using extended environment with top- level variables of base code

29. 29 Weaving with Type Information Generates type safe woven code from typed base code and typed aspect code –judges join points that advices are woven into kinds of pointcut specified names type information of each code –reflects type extensions as changing corresponding type declarations

30. 30 Example of Weaving type t = Add of t * t | Num of int | Let of string * t * t | Var of string let rec eval env t = match t with Add(t1, t2)  (eval env t1) + (eval env t2) | Num(i)  i | Let(s, t1, t2)  eval ((s, eval env t1)::env) t2 | Var(s)  List.assoc s env aspect SubExtension type t =... | Sub of t * t advice eval_sub = [around (call eval env t)] match t with Sub(t1, t2)  let e = eval env in e t1 - e t2 | _  proceed t end

31. 31 Type Extension type t = Add of t * t | Num of int | Let of string * t * t | Var of string let rec eval env t = match t with Add(t1, t2)  (eval env t1) + (eval env t2) | Num(i)  i | Let(s, t1, t2)  eval ((s, eval env t1)::env) t2 | Var(s)  List.assoc s env aspect SubExtension type t =... | Sub of t * t advice eval_sub = [around (call eval env t)] match t with Sub(t1, t2)  let e = eval env in e t1 - e t2 | _  proceed t end type declaraion in woven code includes the constructor “Sub”

32. 32 Woven Code type t = Add of t * t | Num of int | Let of string * t * t | Var of string | Sub of t * t

33. 33 aspect SubExtension type t =... | Sub of t * t advice eval_sub = [around (call eval env t)] match t with Sub(t1, t2)  let e = eval env in e t1 - e t2 | _  proceed t end type t = Add of t * t | Num of int | Let of string * t * t | Var of string let rec eval env t = match t with Add(t1, t2)  (eval env t1) + (eval env t2) | Num(i)  i | Let(s, t1, t2)  eval ((s, eval env t1)::env) t2 | Var(s)  List.assoc s env Weaving Judgment specifies function calls to “eval”

34. 34 type t = Add of t * t | Num of int | Let of string * t * t | Var of string let rec eval env t = match t with Add(t1, t2)  (eval env t1) + (eval env t2) | Num(i)  i | Let(s, t1, t2)  eval ((s, eval env t1)::env) t2 | Var(s)  List.assoc s env aspect SubExtension type t =... | Sub of t * t advice eval_sub = [around (call eval env t)] match t with Sub(t1, t2)  let e = eval env in e t1 - e t2 | _  proceed t end Weaving Judgment eval : β  t  int env : β t : t eval:(string*int)list  t  int env:(string*int) list t1 : t weaves the advice into the join point types of the pointcut matches types of the applications type safe substitution β = (string*int) list

35. 35 Woven Code type t = Add of t * t | Num of int | Let of string * t * t | Var of string | Sub of t * t let rec eval env t = match t with Add(t1, t2)  (eval_sub eval env t1) + (eval_sub eval env t2) | Num(i)  i | Let(s, t1, t2)  eval_sub eval ((s, eval_sub eval env t1)::env) t2 | Var(s)  List.assoc s env let rec eval_sub proceed call eval env t = match t with Sub(t1, t2)  let e = eval env in e t1 - e t2 | _  proceed t end function definition for advice

36. 36 aspect SubExtension type t =... | Sub of t * t advice eval_sub = [around (call eval env t)] match t with Sub(t1, t2)  let e = eval env in e t1 - e t2 | _  proceed t end Example of Weaving let eval t u = t + u in eval 2 3 eval : int  int  int types of the pointcut does not match types of the application do not weave the advice into the join point eval : β  t  int env : β t : t

37. 37 Key Designs of Aspectual Caml Curried pointcuts Type extension mechanism Weaving with type inference for aspects 2 kinds of pointcuts –polymorphic pointcuts writing pointcuts without explicit type annotations –monomorphic pointcuts identifying join points specified by pointcuts only from their definitions

38. 38 Why 2 Kinds of Pointcuts? Writing pointcuts without type annotations –explicit type annotations are tedious “pointcut call_eval t = call eval t” is better rather than “pointcut call_eval t = call (eval: (string* int) list  t  int) (t: t)” –automatic type inference is needed –familiar requirement for ML programmers

39. 39 Why 2 Kinds of Pointcuts? Identifying join points specified by pointcuts only from their definitions –different advices using the same pointcuts should affect the same join points … ……… ….. …… ………………. …………. …….. pointcut logpoint = … advice a = [after logpoint] … advice b = [before logpoint]...

40. 40 2 Conflicting Requirements Automatic type inference can instantiate types of pointcut variables differently –cf. types of polymorphic functions’ arguments

41. 41 Advices with the Same Pointcuts May Affect Different Join Points pointcut logpoint x = call List.assoc x advice before_trace = [before logpoint x] print_string (“enter:" ^(string_of_int x)) advice after_trace = [after logpoint x] print_string “leave” enter:3 enter:2 leave enter:0 leave … expected result: always paired

42. 42 pointcut logpoint x = call List.assoc x advice before_trace = [before logpoint x] print_string (“enter: " ^(string_of_int x)) advice after_trace = [after logpoint x] print_string “leave” Specifies applications to “assoc” Advices with the Same Pointcuts May Affect Different Join Points

43. 43 Advices with the Same Pointcuts May Affect Different Join Points pointcut logpoint x = call List.assoc x advice before_trace = [before logpoint x] print_string (“enter:" ^(string_of_int x)) advice after_trace = [after logpoint x] print_string “leave” 2 advice decls. using the same pointcut “logpoint” traces before calls to “assoc” traces after calls to “assoc”

44. 44 Advices with the Same Pointcuts May Affect Different Join Points pointcut logpoint x = call List.assoc x advice before_trace = [before logpoint x] print_string (“enter:" ^(string_of_int x)) advice after_trace = [after logpoint x] print_string “leave” used as int any type

45. 45 Advices with the Same Pointcuts May Affect Different Join Points pointcut logpoint x = call List.assoc x advice before_trace = [before logpoint x] print_string (“enter:" ^(string_of_int x)) advice after_trace = [after logpoint x] print_string “leave” used as int any type match different join points

46. 46 This output is not intended result pointcut logpoint x = call List.assoc x advice before_trace = [before logpoint x] print_string (“enter:" ^(string_of_int x)) advice after_trace = [after logpoint x] print_string “leave” output enter:2 leave enter:3 leave … base code assoc 2 int_env assoc 3 int_env assoc “a” string_env … “leave” without “enter”!

47. 47 Proposal: 2 Kinds of Pointcuts Polymorphic pointcuts –variable types in pointcuts are inferred from advice bodies –one pointcut used in different advice decls may match different join points Monomorphic pointcuts –variable types must not be instantiated in advice bodies –one pointcut used in any advice decl matches the same join points example: call (List.assoc:int  (int * string) list  string) x y

48. 48 Current Implementation Source to source translator Extension of O’Caml compiler Essential AOP features are implemented –type extension –around advice –2 kinds of pointcuts –type inference of aspects –weaving –most primitive pointcuts except for wild card call, exec, match, and, within

49. 49 Related Work AspectJ [Kiczales et al. 2001] –a mature AOP language –practical with various AOP features –AOP features of Aspectual Caml import from AspectJ –too complicated for theoretical analysis

50. 50 Related Work MiniAML [Walker et al. 2003] –proposes minimal typed functional AOP language core calculus –defines semantics of the calculus and proves its soundness –the semantics of MiniAML are defined as a translation into the calculus TinyAspect [Aldrich 2004] –for studying interference between aspects and modules –proposes small typed functional AOP language including module system –defines the semantics and proves its soundness

51. 51 Related Work polymor -phism pointcut type extension semantics definition module system soundness proof MiniAML only call with 1 arg TinyAspect only call with 1 arg Aspectual Caml many

52. 52 Conclusion Designed and implemented a practical AOP language based on a typed functional language Proposed solutions to problems in adaptations AOP to functional languages –curried pointcuts –weaving and type inference for aspects –2 kinds of pointcuts –type extension mechanism

53. 53 Future Work Define formal semantics Study well-typedness properties at aspects Implement βversion Introduce more expressive AOP features

54. 54 Fin

55. 55 Problems of Constructor Addition New constructor makes pattern matches in base code non-exhaustive –aspect programmers should supplement the lack case of pattern matches declaring proper advices –this non-exhaustiveness can be found using information in type check of woven code

56. 56 Default Value of Field Addition Aspect programmers should set proper initial values for new fields using advices Without proper advices default values preserve type safety of woven code

57. 57 aspect LogAssoc advice log_assoc [around call assoc elem env] print_string (“assoc with:”^elem^”\n”); proceed env end Judgment of Weaving or Not let assoc1 = assoc “str” … assoc1 env … assoc1 env2 … assoc 20 env3 Types and names are used to judge whether weave or not

58. 58 aspect LogAssoc advice log_assoc [around call assoc elem env] print_string (“assoc with:”^elem^”\n”); proceed env end let assoc1 = assoc “str” … assoc1 env … assoc1 env2 … assoc 20 env3 assoc:string  (string * α) list  α assoc:string  β  γ type safe substitution: β = (string * α) list, γ = α the advice body can be evaluated preserving type safety of target code Types and names are used to judge whether weave or not Judgment of Weaving or Not

59. 59 Types and names are used to judge whether weave or not aspect LogAssoc advice log_assoc [around call assoc elem env] print_string (“assoc with:”^elem^”\n”); proceed env end let assoc1 = assoc “str” … assoc1 env … assoc1 env2 … assoc 20 env3 assoc:int  (int * α) list  α assoc:string  β  γ no substitutions preserve type safety evaluation of the advice body destroys type safety of target code at the join point Judgment of Weaving or Not

60. 60 Flow of Compile Ocaml Source Aspect Source type inference type inference for aspects typed Ocaml AST typed Aspect weave with types type extension Woven program

61. 61 aspect LogAssoc advice log_assoc [around call assoc elem env] print_string (“assoc with:”^elem^”\n”); proceed env end assoc:α  β  γ elem:α env:β type inference of pointcuts does not use type information of target code (assoc:α  (α*β) list  β) Example of Aspect Type Inference

62. 62 aspect LogAssoc advice log_assoc [around call assoc elem env] print_string (“assoc with:”^elem^”\n”); proceed env end assoc:α  β  γ elem:α env:β proceed:β  γ “proceed” means the continuation that takes the 2nd argument of “assoc” and returns the result Example of Aspect Type Inference

63. 63 aspect LogAssoc advice log_assoc [around call assoc elem env] print_string (“assoc with:”^elem^”\n”); proceed env end infer the type of the advice body with the type environment extended with bound variables and “proceed” assoc:α  β  γ elem:α env:β proceed:β  γ Example of Aspect Type Inference

64. 64 aspect LogAssoc advice log_assoc [around call assoc elem env] print_string (“assoc with:”^elem^”\n”); proceed env end assoc:string  β  γ elem:string env:β proceed:β  γ Example of Aspect Type Inference

65. 65 aspect LogAssoc advice log_assoc [around call assoc elem env] print_string (“assoc with:”^elem^”\n”); proceed env end the expected type is the return type of “proceed” Example of Aspect Type Inference the type of this expression matches the expected type

66. 66 aspect LogAssoc advice log_assoc [around call assoc elem] print_string (“assoc with:”^elem^”\n”); proceed elem end Limitation of Simple Call Pointcuts Impossible to specify applications to partially applied functions let assoc1 = assoc “str” … assoc1 env … assoc1 env2 … assoc 20 env3 specifies applications to “assoc”

67. 67 aspect LogAssoc advice log_assoc [around call assoc elem] print_string (“assoc with:”^elem^”\n”); proceed elem end Limitation of Simple Call Pointcuts Impossible to specify applications to partially applied functions let assoc1 = assoc “str” … assoc1 env … assoc1 env2 … assoc 20 env3 defines advice code

68. 68 aspect LogAssoc advice log_assoc [around call assoc elem] print_string (“assoc with:”^elem^”\n”); proceed elem end Limitation of Simple Call Pointcuts Impossible to specify applications to partially applied functions let assoc1 = assoc “str” … assoc1 env … assoc1 env2 … assoc 20 env3 impossible to specify 2nd applications to functions “assoc” since it takes 2 arguments

69. 69 Proposal: Curried Pointcuts Curried pointcuts allow to easily specify applications to curried functions –call/exec pointcuts in AspectJ can specify only 1st applications “call assoc elem env” specifies 2nd applications to functions “assoc”

70. 70 aspect LogAssoc advice log_assoc [around call assoc elem env] print_string (“assoc with:”^elem^”\n”); proceed env end Design for Curried Pointcuts let assoc1 = assoc “str” … assoc1 env … assoc1 env2 … assoc 20 env3 Specify applications to variables bound to partially applied closures

71. 71 Aspect-Oriented Programming (AOP) modularizing program units over multiple modules –Better readability and flexibility of programs industrial benefits –refactoring a huge product with AspectJ [Adrian et.al 2004] crosscutting concerns

72. 72 aspect LogAssoc advice log_assoc=[around call assoc elem] print_string (“assoc with:”^elem^”\n”); proceed elem end An Example of an Aspect Definition Logging function calls to “assoc”

73. 73 aspect LogAssoc advice log_assoc [around call assoc elem] print_string (“assoc with:”^elem^”\n”); proceed elem end An Example of an Aspect Definition specifies “function calls to assoc” Logging function calls to “assoc”

74. 74 aspect LogAssoc advice log_assoc [around call assoc elem] print_string (“assoc with:”^elem^”\n”); proceed elem end An Example of an Aspect Definition execution points of applications to a function named “assoc” prints a message Logging function calls to “assoc”

75. 75 Logging function calls to “assoc” aspect LogAssoc advice log_assoc [around call assoc elem] print_string (“assoc with:”^elem^”\n”); proceed elem end An Example of an Aspect Definition execution points of applications to a function named “assoc” print the message pointcut advice body