Differences

This shows you the differences between two versions of the page.

--- at:tutorial:actors [2008/08/01 14:43] – * tvcutsem
+++ at:tutorial:actors [2008/11/03 10:00] – added tvcutsem
@@ Line 26: / Line 26: @@
   };
 };
->><far ref to:<object:1555668>>
+>><far ref:behaviour of <actormirror:9501984>>
 </code>
@@ Line 70: / Line 70: @@
   };
 };
->><far ref to:<object:11600335>>
+>><far ref:behaviour of <actormirror:14115383>>
 </code>
@@ Line 319: / Line 319: @@
 <code>
+// to create an explicit future:
 def [future, resolver] := makeFuture();
-consumer<-give(future);
-def val := /* calculate useful value */
+// to explicitly resolve a future
 resolver.resolve(val);
 </code>
@@ Line 328: / Line 329: @@
 The resolver also defines a ''ruin(e)'' method which can be used to explicitly ruin a future, causing any attached ''when:becomes:catch:'' blocks to trigger their ''catch:'' clause.
+As an example of such conditional synchronization, consider the following example first proposed by Henry Lieberman in his 1987 paper on "Object-oriented Programming in ACT-1". A dating service allows lonely hearts to register their profile allowing it to match people based on their profiles. The dating service can be modelled as an object:
+<code>
+def makeDatingService() {
+  def people := []; // a list of Questionnaire objects
+  object: {
+    def match(lonelyHeart) {
+      // if an ideal mate is found in the list,
+      //   return its name
+      // otherwise
+      //   create a future (a "promise") to answer
+      //   the lonelyHeart later, when an ideal made
+      //   has registered with the dating service
+    }
+  }
+}
+</code>
+Let us assume that a person is simply identified by a name and its sex:
+<code>
+def makePerson(nam, sx) {
+  object: {
+    def name := nam;
+    def sex := sx;
+  }
+};
+</code>
+The dating service has a little database stored as a simple list. This list does not contain person objects but rather Questionnaire objects. The questionnaire contains the logic necessary to match people. We will assume for the sake of the example that 2 people match if they are of the opposite sex. In addition, a questionnaire object can keep track of an "outstanding answer" (which we model as a first-class future) for a lonely heart that is still waiting for his or her perfect match.
+<code>
+def makeQuestionnaire(p) {
+  def idealPersonResolver;
+  object: {
+    def person := p;
+    def matches(otherQ) { otherQ.person.sex != p.sex };
+    def wait() {
+      def [future, resolver] := makeFuture();
+      idealPersonResolver := resolver;
+      future
+    };
+    def notify(name) { idealPersonResolver.resolve(name) };
+  };
+};
+</code>
+When a questionnaire is asked to ''wait()'', it returns a future and stores the future's corresponding resolver in a hidden field. Later, when a matching person is found, the future can be explicitly resolved by invoking the questionnaire's ''notify'' method.
+Armed with these abstractions, we can now fill in the missing logic of the ''match'' method of the dating service:
+<code>
+def makeDatingService() {
+  def people := []; // a list of Questionnaire objects
+  object: {
+    def match(lonelyHeart) {
+      def lonelyHeartQ := makeQuestionnaire(lonelyHeart);
+      { |return|
+        people.each: { |idealMateQ|
+          // an ideal mate was found
+          if: (idealMateQ.matches(lonelyHeartQ).and: { lonelyHeartQ.matches(idealMateQ) }) then: {
+            idealMateQ.notify(lonelyHeart.name); // notify idealMate
+            // remove the person from the database
+            people := people.filter: { |q| q != idealMateQ };
+            return(idealMateQ.person.name) // notify lonelyHeart
+          }
+        };
+        // no ideal mate was found, store its questionnaire in the database
+        people := people + [lonelyHeartQ];
+        lonelyHeartQ.wait(); // return a future for the ideal person's name
+      }.escape();
+    }
+  }
+}
+</code>
+Below, we define an auxiliary method that illustrates how a lonely heart has to interact with the dating service.
+<code>
+def d := makeDatingService();
+def register(p) {
+  when: d<-match(p)@FutureMessage becomes: { |name|
+    system.println(p.name + " matched with " + name);
+  };
+};
+</code>
+The key to our conditional synchronization is that the ''when:becomes:'' listener will only be invoked if and when a matching person has registered itself with the dating service. As long as this condition has not been fulfilled, the future will remain unresolved. In fact, the future returned by ''d<-match(p)'' has been resolved with another future, the one returned by ''Questionnaire.wait()''. However, recall that a future resolved by another unresolved future does not really count as being "resolved" and will only trigger its listeners once its "dependent" future has been resolved.
 ===== Actor Mirrors =====