all FREECO11-workshop-papers.pdf - trese

More documents

Recommendations

Info

(define eval (lambda (exp env)(cond((symbol? exp) (cdr (assoc exp env)))((atom?(’texp) exp)(let ((fn (eval (car exp) env)))(if (fixed? fn)(apply (-function fn) (cdr exp) env)(apply fn (evlis (cdr exp) env) env)))))))(define apply (lambda (fun args env)(cond((subr? fun) {call (-implementation fun) args env} )((expr? fun) (eval (-body fun) (pairlis (-formals fun) args (-environment fun)))))))(define %type-names (tuple))(define %type-sizes (tuple))(define %type-fields (tuple))Figure 1: Evaluation of symbolic expressions in a minimal functional language(define %allocate-type(let ((last-type number-of-builtin-types ))(lambda (name fields)(let ((type (set last-type (+ 1 last-type))))(set-tuple-at %type-names type name)(set-tuple-at %type-sizes type (list-length fields))(set-tuple-at %type-fields type fields)type))))(define (%allocate-type ’ ’(x y)))(define -x (lambda (value)(and (= (type-of value))(tuple-at value 0))))Figure 2: Adding an aggregate type to the languages are closures carrying the environment in whichthey were defined. Variable lookup is lexically scoped. (Atrivial change to the last line in Figure 1 gives LISP’s dynamicscoping.) Additional atomic types such as numbers,and primitives that act on them, will be present in a practicallanguage of this kind. They are omitted here for brevity.3. SUPPORTING OPEN COMPOSITIONThe language just described supports one combining form(the list). When a list is evaluated it causes a compositionin which each of the element(s) being combined is recursivelyevaluated yielding one or more values, the first ofwhich is then applied (as a function) to the rest (the arguments).“Open composition” means the ability to add newcompositions (or replace existing ones) corresponding to theevaluation of new (or existing) combining forms.Modifications to the language will be made to support:• defining new types, to represent the syntactic operators,state and semantics of composition mechanisms, and• associating meaning with combinations involving thesenew types.3.1 Extensible aggregate typesPredicates in eval and apply use some property of a value todiscriminate between types. The simplest generalisation isto identify each type with a unique integer. Incrementing acounter suffices to allocate a new type. A primitive functiontype-of yields the type identifier for a given value.Three types (, and s for constructinglists) appear in the evaluator that are aggregates of values.Aggregation can be generalised to a single mechanism:infinitely-sized, indexable N-tuples containing undefined atall uninitialised indices. 11 Assignment at an uninitialised index extends the tuple asnecessary.With these mechanisms addition of a new aggregate typecan be effected in user code, as shown in Figure 2. 2 Norestrictions have been placed on the structure or semanticsof objects. Intrinsic types (those used by the evaluator)are built from the same parts: there is no disparity betweenbuilt-in and user-defined types and values.3.2 Extensible composition rulesTwo kinds of composition occur in the evaluator. Simpleatomic expressions (symbols in particular) are composedwith the environment by eval to yield a value. Combinationsof one or more values in complex expressions arecomposed by apply by application of a primitive or closurevalue to the remaining values. Both of kinds of compositionare made extensible by applying an appropriate combinationmechanism to every expression according to its type. Twotuples, evaluators and applicators, are indexed by type ineval and apply, respectively.eval(x, e) =apply(evaluators[type(x)], cons(x, nil),e)apply(f, a, e) =apply(applicators[type(f)], cons(f, a),e)Four consequences of this decomposition are:• any applicable value can supply the composition semanticsfor any expression, simple or complex,• any value can be made applicable, with semantics determinedby its type and its value,• the meaning of a complex expression (explicit combinationof values, e.g., as a list) is not fixed, or evensupplied, by the evaluation mechanism, and2 The steps shown allocate the type, record information forprinting and instantiating, and define an accessor for an instancefield. In practice these steps are generated automaticallyfrom a single define-type expression, given a typename and a list of field names, along with the implied set of-field accessors.
(define eval (lambda (exp env)(apply (tuple-at evaluators (type-of exp)) (list exp env) env)))(define apply (lambda (fn args env)(if (subr? fn){call (-implementation fn) args env}(apply (tuple-at applicators (type-of fn)) (list fn args env) env))))Figure 3: Generalised assignment of meaning to expressions(set-tuple-at evaluators (lambda (exp env) (cdr (assoc exp env))))(set-tuple-at evaluators (lambda (exp env) exp))(set-tuple-at evaluators (lambda (exp env)(let ((fn (eval (car exp) env)))(if (eq (type-of fn) )(apply (-function fn) (cdr exp) env)(apply fn (evlis (cdr exp) env) env)))))(set-tuple-at applicators (lambda (fn args env)(eval (-body fn) (pairlis (-formals fn) args (-environment fn)))))Figure 4: The original language semantics expressed as composition rules(define-type (function))(define form (lambda (function)(let ((self (new )))(set (-function self) function)self))(set-tuple-at *applicators* (lambda (fn args env)(eval (apply (-function fn) args env) env)))Figure 5: Form type for defining macros• apply is an infinitely-recursive function.Infinite recursion is avoided by short-circuiting the semanticsof applying a primitive, as shown in Figure 3. Four entriesin the evaluators and applicators tuples, as shown inFigure 4, restore the original semantics to the language.Associating evaluators and applicators with env (effectivelybinding them in the environment) permits great flexibilityin assigning meaning to program constructs, includingincremental extension or modification of existing compositionmechanisms, and multiple context-sensitive semanticsfor any given type. (The latter is pivotal when modellinglanguage implementation as a series of partial evaluations,which is the motivation for an “open composition model”.)4. DEFINING NEW COMPOSITIONSThree new compositions will be added to the language: a value (for defining macros), object-oriented messagepassing and generic functions. (We assume a quasiquotationmechanism, which is straightforward given .)4.1 Forms and macrosFigure 5 introduces an applicable type, encapsulatingsome other applicable value. The encapsulated value isapplied to the arguments and then the result is re-evaluated.Placing a inside a creates a macro.4.2 Message passingMessage passing sends a message with zero or more argumentsto an object that executes a corresponding method.The method is typically chosen by combining the type of theobject with the name (selector) of the message:type × selector → methodObjects scan store (usually in their type) a table of methodsindexed by selector, or selectors can store a table of methodsindexed by type. 3 The implementation in Figure 6 choosesthe latter. 44.3 Generic functionsA generic function contains several function implementations.When applied, the generic function uses some propertyof each of its arguments to choose which implementationwill be executed. The type of each argument is often used. 5Figure 7 shows a simple model of generic functions. 6 Tuplesare organised as a sparse multi-dimensional array. Successivedimensions correspond to successive argument positions.For each dimension the tuple maps a type id to thetuple for the next argument position, until the final tuplewhich maps type to the implementation function.5. DISCUSSIONThe preceding compositions can be modelled in the languageof Section 2 by a closure implementing dispatch through aclosed-over list-based structure containing the required map.Accessing (for inspection or manipulation) the structure isone source of the “complexity and obfuscation” mentionedin the introduction, demanding knowledge of the internalstructure and implementation of closures and environments.3 Each has advantages compared with the other. Both wouldbe present in a comprehensive model of message passing.4 This breaks encapsulation, a precept of object-orientation.Order can be restored by storing an association list witheach type to map selector names to methods. Then looks up the method and memoises it, in the structureshown here, before invoking it. Lookup need not be efficientbecause of the memoisation. Chaining s togetherpermits enumeration to flush memoised results whenevermethod dictionaries are manipulated. Such an implementationof is one line longer than that shown.5 The simplest property to use is equality with a constantbut the resulting behaviour is of limited use.6 This model uses equality to compare the list of actual argumenttypes and the type signature associated with eachimplementation. If an ordering relation can be defined fortypes then more interesting comparisons can be used, tofind the ‘closest admissible’ implementation when actual argumenttypes do not precisely match an implementationfunction signature. As with selectors, the comparison neednot be efficient because the result can be memoised in the’s array.
Page 1 and 2: FREECO-11Table of ContentsTable of
Page 3 and 4: 1 Policy (Id = ”Service Levels”
Page 5 and 6: the level of assertions. On the oth
Page 7 and 8: An association-based model of dynam
Page 9 and 10: that, when substituted back into r
Page 11 and 12: This suggests using the association
Page 13 and 14: class-based languages like Java and
Page 15 and 16: • The keywords final in Java, con
Page 17 and 18: Composing heterogeneous software wi
Page 19 and 20: 3. APPROACHOur approach consists of
Page 21 and 22: example, the naming convention we s
Page 23 and 24: 2. We present a novel approach and
Page 25 and 26: CG Template 1CG Template 2...CodeSl
Page 27: Open, extensible composition models
Page 31 and 32: defined to combine values into comp
Page 33 and 34: • a proof that the model transfor
Page 35 and 36: have been proposed that allow parts
Page 37 and 38: FREECO-11Author IndexAuthor IndexBe

all FREECO11-workshop-papers.pdf - trese

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?