Date post: | 05-Jan-2016 |
Category: |
Documents |
Upload: | hubert-wilkerson |
View: | 212 times |
Download: | 0 times |
CSG 711 1
Structure and Interpretation of an Aspect Language
for Datatype Karl Lieberherr
CSG 711 2
2 Lectures
• The motivation and theory behind “Aspect Language for Datatype”.– datatypes and class graphs – Semantics (// A B) (navig-object graphs.*)– Visitors and type checking
• Interpreter implementation
CSG 711 3
Motivation
• Build on foundations that Matthias presented.• Connections to templates: stressing the
importance of structural recursion.• Not only an interpreter but also a compiler
(works, because traversals are sufficiently simple).
• Very useful application of foundations that is in itself a foundation.
• Demonstration that simple languages can be full of surprises.
CSG 711 4
Homework
• Simple aspect-oriented language.
• Leads to a radically different way of programming: programming without knowing details of data structures. Write programs for a family of related data structures.
• Northeastern SAIC project ca. 1990.
CSG 711 5
Homework evolution
• Initial motivation: make EOPL datatype style programming easier by adding a traverse function.
• Visitors written in full Scheme: AdaptiveScheme = Scheme + EOPL datatype + traversal strategies + visitors.
• You get a simplified form (thanks Matthias).
CSG 711 6
Interpretation
• Interpret a traversal on an object tree.
• (join (//A B) (//B C)): starting at an A-node, traverse entire object tree, return C-nodes that are contained in B-nodes that are in turn contained in A-nodes.
• Not interesting enough. Can meta information about object trees make it more interesting?
CSG 711 7
Interpretation with meta information
• Use a graph to express meta information.
• Many applications: – data type / data trees– class graph / object trees– schema / documents (XML)– programs / execution trees
CSG 711 8
Class graphs(simplified UML class diagrams)
• nodes and edges
• nodes: concrete and abstract
• edges: has-a (triples) and is-a (pairs)
• concrete nodes: no incoming is-a
• supports inheritance
• flat: a class graph is flat if no abstract node has an outgoing has-a edge
CSG 711 9
Example B2
A
R
BX
S
D
0..1
0..1
0..1
C
T0..1
A//T//D
a1:A
r1:R
s1:Sc1:C
d1:D
classgraph
strategy
t1:T
r2:R
c2:C
d2:D
s2:S
object graph
CSG 711 10
Plan
• (M s cg og) = ?– (M1(M2 s cg) og) = ?– og satisfies cg!
• Not only traverse!• (Mv s cg og V)
– (Mv1 (M1 (M2 s cg) og) V)– visitor V: before / after applications to node /
edge. Local storage. Visitor functions are activated by traversal.
CSG 711 11
Sample visitor
(visitor PersonCountVisitor
0 // initial value
PersonCountVisitor // return
before (host Person)
(+ PersonCountVisitor 1)
)
CSG 711 12
Example
• (Mv s cg og PersonCountVisitor)
• cg : class graph for bus routes
• og: object graph for bus routes
• s = (join (// BusRoute BusStop)
(// BusStop Person))
count all persons waiting at any bus stop on a bus route
CSG 711 13
Class Graph
BusRoute BusStopList
BusStopBusList
Bus PersonList
Person
passengers
buses
busStops
waiting
0..*
0..*
0..*
count all persons waiting at any bus stop on a bus route
CSG 711 14
Object Graph
Route1:BusRoute
:BusStopListbusStops
CentralSquare:BusStop
:PersonList
waiting
Daniel:Person Viera:Person
BusListbuses
Bus15:Bus
:PersonList
passengers
Christine:Person
Bryan:Person s = (join (// BusRoute BusStop) (// BusStop Person))
(Mv s cg og PersonCountVisitor) = ??
c=0
c++ c++
CSG 711 15
Robustness
BusRoute BusStopList
BusStopBusList
Bus PersonList
Person
passengers
bussesbusStops
waiting
0..*
0..*
0..*
s = BusRoute // BusStop // Person
VillageList
Village
villages
0..*
count all persons waiting at any bus stop on a bus route
c=0
c++
CSG 711 16
Aspects
• Aspects as program enhancers
• Here we enhance traversal programs with before and after advice defined in aspects called visitors
• General AOP enhances any kind of program
• This is a special case with good software engineering properties
CSG 711 17
Develop a sequence of semantics
• (M s cg og) = ?– og satisfies cg!
• s, cg, og: are graphs. Graphs are relations. Use terminology of relations.
• Restrict to s = (// A B).
CSG 711 18
Object level semantics
• (M s cg og), where s = (// A B).
• The key is to find a set FIRST(A,B) of edges such that e in FIRST(A, B) iff it is possible for an object of class A to reach an object of type B by a path beginning with an edge e.
• (M s cg og) is the FIRST(A,B) sets.
CSG 711 19
Homework class graphs
A CG is: (DD+)
A DD is: (datatype TypeName Alternative+) An Alternative is: (AlternativeName (FieldName TypeName)
+)
HW class graph to class graph transformation:TypeName -- abstract classAlternativeName – concrete class(AlternativeName, FieldName, TypeName) – has-a(AlternativeName, TypeName) – is-a
CSG 711 20
Homework class graphs
CD = PL(DD).DD = "(datatype" TypeName L(Alternative) ")".Alternative = "(" AlternativeName L(TypedField)
")".TypedField = "(" FieldName TypeName ")".FieldName = Ident.TypeName = Ident.AlternativeName = Ident.L(S) ~ {S}.PL(S) ~ "(" {S} ")".
CSG 711 21
Class graph example (datatype Container (a_Container (contents ItemList) (capacity Number) (total_weight Number))) (datatype Item (Cont (c Container)) (Simple (name String) (weight Weight)))
(datatype Weight (a_Weight (v Number))) (datatype ItemList (Empty) (NonEmpty (first Item) (rest ItemList))))
HW class graph to class graph transformation:TypeName -- abstract classAlternativeName – concrete class(AlternativeName, FieldName, TypeName) – has-a(AlternativeName, TypeName) – is-a
traversal strategy:(// a_Container a_Weight)
CSG 711 22
As traditional class graph
Container
aContainer
ItemList Number
contentscapacity
total_weight
Empty NonEmpty
Item
Cont Simple
c
String Weight
name weight
v
first
rest
CSG 711 23
Another class graph example
(datatype P (CP (q Q)))
(datatype Q (CQ (p P)))
Because we only allow trees for object graphs, we should disallow such class graphs? P and Q are useless.
CSG 711 24
F
CBA
D
G
E
HF
CBA
G
E
HClass graphs
object-equivalent
inheritance
CSG 711 25
object-equivalent
inheritance
Class graphs
F
CBA
G
E
H
F
CBA
G
E
H
CSG 711 26
inheritance
Class graphs
F
CBA
G
E
H
H
F
A1
aH
E
G
aE
B1 C1
aG
Preview:(// aH aE)(// aH aG)(// aH Hid_A)
CSG 711 27
inheritance
Evolution
F
CBA
G
E
H
H
F
Hid_A
aH
E
G
aE
Hid_B Hid_C
aG
B
aB
not evolution-friendly
CSG 711 28
inheritance
Class graphs
F
CBA
G
E
H
H
F
A1
aH
E
G
aE
B1 C1
aG
Preview:(// aH aE)(// aH aG)(// aH Hid_A)
CBA
aA aB aC
now evolution-friendly
CSG 711 29
inheritance
Class graphs
F
CBA
G
E
H
H
F
A1
aH
E
G
aE
B1 C1
aG
Preview:(// aH aE)(// aH aG)(// aH Hid_A)
CBA
aA aB aC
CSG 711 30
inheritance
Class graphs
F
CBA
G
E
H
H
F
A1
aH
E
G
aE
B1 C1
aG
Preview:(// aH aE)(// aH aG)(// aH Hid_A)
CBA
aA aB aC
E1
CSG 711 31
inheritance
Class graphs
F
CBA
G
E
H
(datatype H (aH (f F) (b B) ))(datatype G (aG))(datatype A (aA (e E) (g G)))(datatype B (aB (e E) (g G)))(datatype C (aC (g G)))(datatype E (aE))(datatype F (A1 (a A)) (B1 (b B)) (C1 (c C)) (E1 (e E)) )
H = F B.G = .A = E G.B = E G.C = G.E = .F : A | B | C | E .
CSG 711 32
Separate Viewgraphs
• Difference between homework class graphs and class graphs.
• No inheritance in homework class graphs.
• Flat class graphs can easily be modeled by home work class graph. A class graph is flat if abstract classes have no outgoing has-a edges. Quadratic growth in size.
CSG 711 33
Apply class graph knowledge to homework class graphs
• Only consider flat class graph (flattening is an object preserving transformation).
• In flat class graph the rules are simpler.
HW class graph to class graph transformation:TypeName -- abstract classAlternativeName – concrete class(AlternativeName, FieldName, TypeName) – has-a(AlternativeName, enclosing TypeName) – is-a
CSG 711 34
Meaning of strategies and visitors
• (// A B) (only this in hw)– A:AlternativeName B:AlternativeName– starts at A-object and ends at B-object
• (// A B)– A:TypeName B:TypeName– starts at an AlternativeName-object of A– ends at an AlternativeName-object of B
CSG 711 35
From Semantics to Interpreter
• From object-level semantics to class-level semantics
• (M1(M2 s cg) og)– M2: FIRST sets at class level
SWITCH to navig-object-graphs
CSG 711 36
From Interpreter to Compiler
• Connect to Structural Recursion
• Consider the strategy (// A *) (everything reachable from A)
• (M1(M2 s cg) og): we want M1 to be apply
• M2 must return a function that we apply to og
• Primitives: functions with one argument: the data traversed, no other arguments.
CSG 711 37
Code generation: should produce something useful
(define-datatype BusRoute BusRoute?
(a-BusRoute
(name symbol?)
(buses (list-of Bus?))
(towns (list-of Town?))))
CSG 711 38
Style 1: display
(define (trav br)
(cases BusRoute br
(a-BusRoute (name buses towns)
(list name (trav-buses buses)
(trav-towns towns)))))
(define (trav-buses lob)
(map trav-bus lob))
CSG 711 39
Style 2: copy
• (define (cp br)
• (cases BusRoute br
• (a-BusRoute (name buses towns) (apply a-BusRoute (list name (cp-buses buses) (cp-towns towns))))))
• (define (cp-buses lob)
• (map cp-bus lob))
CSG 711 40
Summary phase 1
• Language: strategies: A // B, class graphs, object graphs
• Semantics: FIRST: there exists object
• Interpreter: FIRST: there exists path in class graph
• Compiler: generated code is equivalent to a subgraph of class graph
CSG 711 41
Visitors
CSG 711 42
Visitors
• Several kinds: – Think of strategy as making a list out of an og. Fold
on that list.• (cg og s) -> list of target objects of s. (gather cg og s). (//
CContainer CWeight)• (+ (+ … (+ w2 (+ w1 0)) … )
– Think of visitor as having a suit case of variables in which they store data from their trip. Available as argument.
– functions for nodes and edges.– multiple visitors.
CSG 711 43
Type checking of hw programs
• check: Program =(Strategy x Visitor). (Program x ClassGraph) -> Bool
• Fundamental question: Given a program, with respect to which class graphs is it type correct.– Type checking: Given a class graph, is the
program type correct?– Typability: Does there exist a class graph
such that the program is type correct?
CSG 711 44
Reference
• Class-graph Inference for Adaptive Programs, Jdens Palsberg, TAPOS 3 (2), 75-85, 1997.
CSG 711 45
• fix 27
• semantics: go everywhere and collect ogs.
• then apply visitors
• general strats: exponentially many paths