1 / 56

Aspectual Caml an Aspect-Oriented Functional Language

Aspectual Caml an Aspect-Oriented Functional Language. Hideaki Tatsuzawa Hidehiko Masuhara Akinori Yonezawa University of Tokyo. Background: Studies on AOPLs. Practical languages are mostly based on OOPLs Java [Kiczales et al. 2001] C++ [Spinczyk et al. 2002] etc.

elisha
Download Presentation

Aspectual Caml an Aspect-Oriented Functional 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. Aspectual Camlan Aspect-Oriented Functional Language Hideaki TatsuzawaHidehiko MasuharaAkinori Yonezawa University of Tokyo

  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. 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. 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. Motivating Example Aspects Simple Interpreter type extension aspect SubExtension type+ t = ... | Sub of t * tadvice eval_sub =[around (call eval env t)]match t withSub(t1, t2) -> let e = eval env in e t1 - e t2| _ -> proceed tend 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 type declaration of terms extension of function behavior function definition for evaluation of terms logging evaluation of terms aspect LogEvaladvice log_eval =[before (call eval _ _)]print_string “called eval\n”end

  6. Motivating Example Aspects Simple Interpreter aspect SubExtensiontype+ t = ... | Sub of t * tadvice eval_sub =[around (call eval env t)]match t withSub(t1, t2) -> let e = eval env in e t1 - e t2| _ -> proceed tend 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 extension ofthe type declaration specifies 2nd applicationsto function “eval” aspect LogEvaladvice log_eval =[before (call eval _ _)]print_string “called eval\n”end

  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. Key Designs of Aspectual Caml • Curried pointcuts • Type extension mechanism • Weaving with type inference • 2 kinds of pointcuts • polymorphic and monomorphic

  9. Key Designs of Aspectual Caml • Curried pointcuts • Type extension mechanism • Weaving with type inference • 2 kinds of pointcuts • polymorphic and monomorphic Today’smaintopic

  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. Type Extensioncf. inter-type declarations in AspectJ • Constructor addition • Field addition “type+ t = … | Sub t * t” adds the new constructor Subthat 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. 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. Weaving of Type Inference: Background 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

  14. Weaving of Type Inference: Background 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

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

  16. Example of Aspect Type Inference aspect SubExtension type t = ... | Sub of t * tadvice eval_sub = [around (call eval env t)]match t withSub(t1, t2) -> let e = eval env in e t1 - e t2| _ -> proceed tend

  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. Type Inference of Pointcuts eval :α -> β -> γenv : α t : β aspect SubExtension type t = ... | Sub of t * tadvice eval_sub = [around (call eval env t)]match t withSub(t1, t2) -> let e = eval env in e t1 - e t2| _ -> proceed tend does not use type information in base code (eval: (string * int) list -> t -> int)

  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. Type Inference of “proceed” eval :α -> β -> γenv : α t : βproceed : β -> γ aspect SubExtension type t = ... | Sub of t * tadvice eval_sub = [around (call eval env t)]match t withSub(t1, t2) -> let e = eval env in e t1 - e t2| _ -> proceed tend “proceed” means the continuation that takes the 2nd argument of “eval”and returns the result

  21. Type Inference of Advice Body eval :α -> β -> γenv : α t : βproceed : β -> γ aspect SubExtension type t = ... | Sub of t * tadvice eval_sub = [around (call eval env t)]match t withSub(t1, t2) -> let e = eval env in e t1 - e t2| _ -> proceed tend infer the type of the advice bodywith the type environment extended withbound variables and “proceed”

  22. Type Inference of Advice Body eval :α ->t-> γenv : α t : tproceed :t -> γ aspect SubExtension type t = ... | Sub of t * tadvice eval_sub = [around (call eval env t)]match t withSub(t1, t2) -> let e = eval env in e t1 - e t2| _ -> proceed tend

  23. Type Inference of Advice Body eval :α -> t ->intenv : α t : tproceed : t ->int aspect SubExtension type t = ... | Sub of t * tadvice eval_sub = [around (call eval env t)]match t withSub(t1, t2) -> let e = eval env ine t1 - e t2| _ -> proceed tend

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

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

  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. Type Extension type t = Num of int | Add of t * t | Let of string * t * t | Var of string| Sub of t * t aspect SubExtensiontype t = ... | Sub of t * tadvice eval_sub = [around (call eval env t)]match t withSub(t1, t2) -> let e = eval env in e t1 - e t2| _ -> proceed tend extends environment that is used in aspects

  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. 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. 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 * tadvice eval_sub =[around (call eval env t)]match t withSub(t1, t2) -> let e = eval env in e t1 - e t2| _ -> proceed tend

  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 SubExtensiontype t = ... | Sub of t * tadvice eval_sub =[around (call eval env t)]match t withSub(t1, t2) -> let e = eval env in e t1 - e t2| _ -> proceed tend type declaraion in woven code includesthe constructor “Sub”

  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. Weaving Judgment 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 * tadvice eval_sub =[around (call eval env t)]match t withSub(t1, t2) -> let e = eval env in e t1 - e t2| _ -> proceed tend specifies function calls to “eval”

  34. Weaving Judgment eval : β-> t ->int env : β t : t eval:(string*int)list->t-> int env:(string*int) list t1 : t 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 * tadvice eval_sub =[around (call eval env t)]match t withSub(t1, t2) -> let e = eval env in e t1 - e t2| _ -> proceed tend type safe substitution β = (string*int) list types of the pointcut matchestypes of the applications weaves the advice into the join point

  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 withSub(t1, t2) -> let e = eval env in e t1 - e t2| _ -> proceed tend function definition for advice

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

  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. 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. 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. 2 Conflicting Requirements • Automatic type inference can instantiate types of pointcut variables differently • cf. types of polymorphic functions’ arguments

  41. expected result: always paired enter:3 enter:2 leave leave enter:0 leave … Advices with the Same PointcutsMay 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”

  42. Advices with the Same PointcutsMay 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” Specifies applications to “assoc”

  43. Advices with the Same PointcutsMay Affect Different Join Points 2 advicedecls. using the same pointcut “logpoint” 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” traces before calls to “assoc” traces after calls to “assoc”

  44. Advices with the Same PointcutsMay 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. Advices with the Same PointcutsMay Affect Different Join Points match differentjoin 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

  46. This output is not intended result base codeassoc 2 int_envassoc 3 int_envassoc “a” string_env… 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” outputenter:2 leave enter:3 leave leave … “leave” without “enter”!

  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 instantiatedin 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. 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. Related Work • AspectJ [Kiczales et al. 2001] • a mature AOP language • practical with various AOP features • AOP features of Aspectual Caml import fromAspectJ • too complicated for theoretical analysis

  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

More Related