A Type System for Functional Traversal-Based Aspects

Transcription

1 A Type System for Functional Traversal-Based Aspects Bryan Chadwick and Karl Lieberherr March 2 nd / 30

2 Outline Introduction Example (Pure) Semantics Example (Full Dispatch) Type System Soundness 2 / 30

3 Intro: Traversals AOP Modularizes Crosscutting Concerns Traversal is an Important Concern ˆ Walk a Data Structure... Do Some Work ˆ Tedious to Write ˆ Crosscuts Data Definitions 3 / 30

4 Intro: Functional Traversal Functional Traversal ˆ Compute Without Mutation ˆ Multi-threading ˆ Safe But Flexible ˆ Eliminate Implicit Ordering 4 / 30

5 Intro: Functional Traversal Tree Contraction 5 / 30

6 Intro: Functional Traversal Tree Contraction 6 / 30

7 Intro: Functional Traversal Tree Contraction 7 / 30

8 Intro: Functional Traversal Tree Contraction 8 / 30

9 Intro: Functional Traversal Tree Contraction... 9 / 30

10 Goals: Modularity and Safety Separate Traversals and Computation ˆ Traversal Flexibility/Control ˆ Freedom of Implementation ˆ Write Once or Generate from Structures Enforce Safety With Types ˆ Express More of the Computation ˆ Assumptions Are Checked 10 / 30

11 Functional Traversal-Based Aspects Sets of Functions Over a Depth-First Traversal ˆ Each Function Is Advice ˆ Join Points Are After Subtraversals Complete ˆ Pointcuts Are Function Signatures Benefits ˆ Functional! ˆ Type Sound 11 / 30

12 Surface Syntax x C A T ::= variable names ::= concrete type names ::= abstract type names ::= C A P ::= D 1... D n e D ::= concrete C ( T 1,..., T n ) abstract A ( T 1,..., T n ) e ::= x new C ( e 1,..., e n ) traverse( e 0, F ) F ::= funcset(f 1... f n ) f ::= (T 0 x 0,..., T n x n ){ return e; } 12 / 30

13 Example: Boolean Expressions Data Definitions abstract Exp ( Lit, Neg, And, Or) abstract Lit ( True, False ) concrete True () concrete False () concrete Neg ( Exp ) concrete And ( Exp, Exp ) concrete Or ( Exp, Exp ) 13 / 30

14 Example: Boolean Expressions An Expression &! F T F new Or(new And ( new False (), new True ()), new Neg ( new False ())) 14 / 30

15 Example: Boolean Expressions & Or Elimination! F T F funcset ( F T F (True t){ return t; } (False f){ return f; } (Neg n, Exp e) { return new Neg (e); } (And a, Exp l, Exp r){ return new And (l,r); }! & &!!! ) (Or o, Exp l, Exp r){ return new Neg ( new And ( new Neg (l), new Neg (r ))); } 15 / 30

16 Example: Boolean Expressions & Or Elimination! F T F! & &!!! F T F Other Functions Just Reconstruct (Or o, Exp l, Exp r){ return new Neg ( new And ( new Neg (l), new Neg (r ))); } 16 / 30

17 Semantics Traversals and Dispatch ˆ Adaptive Depth-First Traversal ˆ Dispatch on First Argument Type ˆ Enforce Safety With Types Functions ˆ Depend on Argument Order ˆ Can implement Field Access 17 / 30

18 Semantics: Expanded Expanded Dispatch Semantics ˆ Asymmetric Multiple Dispatch ˆ Pattern Matching with Safety Similar to CLOS Generic Functions 18 / 30

19 Example: Refactored Abstract Binary Exp abstract Exp ( Lit, Neg, Bin )... concrete Bin ( Op, Exp, Exp ) abstract Op ( And, Or) concrete And () concrete Or () 19 / 30

20 Example: Refactored Evaluation funcset ( (Lit l){ return l; } (Neg n, True t) { return new False (); } (Neg n, False t){ return new True (); } (Op o){ return o; } (Bin b, And a, True l, True r){ return l; } (Bin b, And a, Lit l, Lit r) { return new False (); } ) (Bin b, Or o, False l, False r){ return l; } (Bin b, Or o, Lit l, Lit r) { return new True (); } 20 / 30

21 Benefits of Extended Dispatch ˆ Abstraction (Lit l){...} (Bin b, And a, Lit l, Lit r){...} Handle Multiple Cases ˆ Type Flexibility (Bin b,...) {...} Lit (Op o){...} Op Not Strictly Type Unifying or Preserving ˆ Type Safety Adding XOr to Op *error* (Bin b, XOr x,...) not handled 21 / 30

22 Type System Connect Static and Dynamic Worlds ˆ Advice Lookup Never Fails ˆ Advice Application Never Fails Enables Flexible Traversal ˆ Dynamic (Reflection) ˆ Heap Based, With/Without Stack ˆ Complete Inlining 22 / 30

23 Typing Rules [T-Var] x : T Γ Γ e x : T [T-New] concrete C ( T 1,..., T n ) P Γ e e i : T i T i T i for all i 1..n Γ e new C ( e 1,..., e n ) : C [T-Func] x i : T i e e 0 : T F (T 0 x 0,..., T n x n ){ return e 0 ; } : T [T-Trav] Γ e e 0 : T 0 T T 0, F : T ; traverse( e 0, F ) : T 23 / 30

24 Traversal Typing Rules [T-CTrav] concrete C ( T 1,..., T n ) P types(choose(f, C)) = (C, T 1,..., T n ) F choose(f, C) : T for all i 1..n T i X X {C} T T i, F : T i ; Φ i T i T i (C, T ) (Φ 1 Φ n) T T Φ = { (T j, T j ) j 1..n T j X } Φ = Φ (Φ 1 Φ n)\(c, ) X T C, F : T ; Φ [T-ATrav] abstract A ( T 1,..., T n ) P for all i 1..n T i X X {A} T T i, F : T i ; Φ i T i T (A, T ) (Φ 1 Φ n) T T Φ = { (T j, T ) j 1..n T j X } Φ = Φ (Φ 1 Φ n)\(a, ) X T A, F : T ; Φ 24 / 30

25 Soundness Type System: Rules Out Runtime Errors ˆ Advice Lookup Never Fails ˆ Advice Application Never Fails ˆ Correctly Predicts Program Result Notables ˆ Complete Functions ˆ Subtype Traversals Return Subtypes 25 / 30

26 Related Work AOP Semantics: Bruns et al. [2004] Jagadeesan et al. [2003] Wand et al. [2004] AOP Soundness: Kammüller and Voesgen [2009] Walker et al. [2003] OO Type Soundness: Igarashi et al. [1999] Flatt et al. [1998] Constraint Type Systems: Palsberg and Schwartzbach [1991] 26 / 30

27 Next Steps Adding Features to the Model ˆ Multiple-dispatch ˆ Function Set Extension ˆ Traversal Control and Abstraction Towards Traditional Adaptive Programming 27 / 30

28 Next Steps Full Language Implementation ˆ Independent ˆ Or in a Future Functional Language Implementation Features ˆ Type Directed Inlining ˆ Type Directed Traversal Generation ˆ Performance results 28 / 30

29 Contact Bryan Chadwick: Karl Lieberherr: DemeterF Home: / 30

30 References Glenn Bruns, Radha Jagadeesan, Alan Jeffrey, and James Riely. µabc: A minimal aspect calculus. In Proceedings of the 2004 International Conference on Concurrency Theory, pages Springer-Verlag, Matthew Flatt, Shriram Krishnamurthi, and Matthias Felleisen. Classes and mixins. In In POPL, pages ACM Press, Atsushi Igarashi, Benjamin Pierce, and Philip Wadler. Featherweight java: A minimal core calculus for java and gj. In TOPLAS, pages , Radha Jagadeesan, Alan Jeffrey, and James Riely. A calculus of untyped aspect-oriented programs. In ECOOP, pages 54 73, Florian Kammüller and Matthias Voesgen. Towards type safety of aspect-oriented languages. In AOSD 2006, FOAL Workshop, Jens Palsberg and Michael I. Schwartzbach. Object-oriented type inference. In OOPSLA, pages , New York, NY, USA, ACM. ISBN doi: David Walker, Steve Zdancewic, and Jay Ligatti. A theory of aspects. In ICFP, pages , New York, NY, USA, ACM. ISBN doi: Mitchell Wand, Gregor Kiczales, and Chris Dutchyn. A semantics for advice and dynamic join points in aspect-oriented programming. TOPLAS, 26(5): , / 30