facets

[Ben Phillips]

This idea is interesting, but also confusing. From what I can tell using
"together" means that the facets 
don't execute linearly, since they depend on each other. Imho this would be very
confusing to code and 
even more confusing to understand. I even have trouble understanding your
example, I can get the 
basics but its confusing how the scopes of all the facets seem to be linked
through the use of "other". 
This leads me to believe that facets would also be very difficult to implement
in a compiler.

In article <du3fib$2blj$1 at digitaldaemon.com>, Kevin Bealer says...
>
>
>I like the on_scope_exit() and friends, by the way.
>
>But it got me thinking about an idea I had.  It's a bit like aspect
>oriented programming, but that is usually done with classes.  This is
>a function based one.  The name I'm thinking of for this is "facet
>programming", sort of suggesting "function based aspects".
>
>The idea is to have semi-independent functions that can be "zipped"
>together at specified points to combine different implementations of
>sub-functionalities, or to add and remove those elements.
>
>Imagine that I have one function that reads lines of data from a file,
>another that reads from a user interface, and I want to process the
>data one line at a time.  I can also have several "consumers" of the
>data.  Here I show two of each.
>
>However, the real power would be in writing a conceptual "script" for
>some sequence of interactions (this is represented as "A: B: C:"
>below).  This script would allow dozens or hundreds of classes to
>interact at controlled places.  Currently this requires writing a
>master function that knows everything about each of the interactions
>between the parts, for all the parts.
>
>The word "facet" defines a facet of the program; "together" indicates
>points that all functions need to reach before any can proceed.  The
>modifier "other" means "find this variable name in one of the other
>aspects instead of locally".  This is sort of like "extern" in C.
>
>: facet void read_from_file(char[] fname)
>: {
>:    together A:
>:       LineReader lr = new LineReader(name);
>:    
>:    bool done = lr.eof();
>:
>:    while(! done) {
>:       char[] line = lr.readLine();
>:       done = lr.eof();
>:    together B:
>:    }
>:   
>:    together C:
>:       lr.close();
>: }
>
>: facet void parse_lines(char[][] lines)
>: {
>:    together A:
>:
>:    bool done = ! lines.length;
>:
>:    while(! done) {
>:       char[] line = lines[0];
>:       lines = lines[1..$];
>:       done = ! lines.length;
>:    together B:
>:    }
>:
>:    together C:
>: }
>
>: void interact_print()
>: {
>:    together A:
>:
>:    while(1) {
>:      together B:
>:        if (other done)
>:            break;
>:
>:        writefln("%s", other line);
>:    }
>:
>:    together C:
>: }
>
>: int sort_and_unique()
>: {
>:    together A:
>:    
>:    int i = 0;
>:    bool[char[]] uniquify;
>:
>:    while(1) {
>:      together B:
>:        if (other done)
>:          break;
>:        
>:        if (! uniquify.find(other line)) {
>:            writefln("%s", other line);
>:            uniquify[other line] = true;
>:        }
>:    }
>:
>:    int count;
>:
>:    together C:
>:      foreach(char[] line; uniquify.keys) {
>:        writefln("%s", line);
>:        count++;
>:      }
>:
>:    return count;
>: }
>
>Some sort of controlling function would be needed to "zip" together
>the facet functions, providing data for their constructors.
>
>: void readAndUnique()
>: {
>:
>:   int count1;
>:
>:   bind_facets {
>:     // runs the following facets simultaneously
>:     // nothing can be here except calls to facets
>:
>:     read_from_file("a.txt");
>:     count1 = sort_and_unique();
>:   }
>:
>:   writefln("%d unique lines", count1);
>: }
>
>The primary goal here is to allow users to "zip in" locking
>(i.e. semaphores), database access, widget set calls, etc.
>
>One other feature: for maximum control, the "together" statement
>should take an optional number:
>
>together(140) C:
>
>The facets with the lowest numbers would be executed first after the
>number is hit.  The facets would all run in the same thread, but the
>compiler is free to mix, reorder, etc. code from different facets as
>long as they all stop and wait for each other to get to the same
>"together" label.
>
>Facet "binding", i.e. construction of the functions would probably
>have to happen at compile time like a template or mixin instantiation.
>
>Kevin
>
>