Hi Doug:

Binoy and I tried to express Mike's in-laws example in
Demeter/Java. We both could not do it. I think the reason is:

With the {A->B ... } notation for general strategy graphs
we cannot have the same class on different strategy graph nodes.
And with the from A to B ... notation for line strategies 
we don't have merge available.

What is your long plan for the two notations: 
the general strategy graph notation and the
strategy line notation?

I think that the strategy line notation is very good to start.
And the general strategy notation is more powerful but we do need
the capability to use the same class as a label of distinct strategy
graph nodes.

This is also linked to defining a name map other than the default name map.
Currently, Demeter/Java supports only the default name map. Maybe
that is all we need. Greg Sullivan was always against any kind of renaming
technique in practical tools.

-- Karl
================
Hi Boaz:

my hope for strategies was also to use them to define
detailed traversals like a path in a class graph:

Person.siblings.Person.spouse.Person

How can this be accomplished?

-- Karl
=====================================
Boaz' Answer:

The detailed path edge A --l--> B
is translated into the strategy graph edge:

A ---------------> B
   only -> *,l,*
   bypassing {A,B}

The constraints apply only to the "inner" nodes.

In the special case A = B, we have:

a1#A --------------> a2#A
     only -> *,l,*
     bypassing {A}

Applying  this to the inlaws problem we get:

>A person object has a reference, spouse to another person object,
>and siblings to a set of Person objects.  An inlaw is either the
>spouse of a sibling or the sibling of a spouse.  The task is
>to find all the inlaws of a given person.

Class graph:
Person = [<spouse> Person] [<siblings> NList(Person)].
NList(S) ~ S {S}.

==========================================================
solution:
==========================================================
The strategy graph is acyclic and has 4 distict nodes labeled Person.
- introduces edge constraints.

start#Person .
(
  - through -> *,spouse,* and bypassing {Person} to sp#Person . 
  - through -> *,siblings,* and bypassing {Person} to inlaw#Person
  +
  - through -> *,siblings,* and bypassing {Person} to si#Person . 
  - through -> *,spouse,* and bypassing {Person} to inlaw#Person
    )

-- Karl

======================================