Hi Mira:

let's discuss in person

some thoughts on how method additions to class-valued variables
should be handled.

I think that an APPC should export one or more methods and that

CVV{APPC with x=y, ...}

should be used to add the exported methods, possibly with a renaming,
to the class valued variable CVV.

Compositions of APPCs:

APPCs which want to be composed must satisfy stringent restrictions.

APPCs which may be composed can only export one method called myRole.
They may only contain one strategy type.

The strategy types of two composed strategies
must be identical or one is a substrategy of the other.

Object communication: there is one return port for each composable
APPC.

We have three operators:

(X || Y)	X and Y are independent (e.g., Pricing and Inventory)
                
(X Y)		X calls Y

(X compose Y)	X calls Y, X and Y communicate directly with APPC to
		the right for input output.

-- Karl

===================
Hi Mira:

What is in the interface of an APPC:

Required interface:

a set of strategy types

a required interface for class valued variables

Provided interface:

one or more methods with signature

a return tuple of objects

========
The form of an adaptive program:

A list of strategy types:
  st1, st2, 

A list of APPCs:
  APPC1 = , APPC2 = , 
  (primitive or built with composition operator)

  The method bodies may contain fragments like:

  x = return {st1; inlined APPC};
  x = return { APPC};

A list of method additions to class-valued variables:
  CVV1 {
    int f1() { return {st1; inlined APPC}; }
    // the main traversal in APPC will be called and myRole
    // corresponds to f1.
    my
  }
  CVV2 {
    float f2() { return { APPC}; }
  }
  CVV3 {
    f3() {APPC}
    // The distinguished function in APPC corresponds to f3
    // and it will activate the needed traversals
    f4() {st1; inlined APPC}
  }

An instantiation of an adaptive program:
A class graph G, a renaming R and a mapping
of strategy types to strategies.