!7

static Map<S, Set<S>> theSet;
static new LinkedHashSet<Updatable> allObjects;
static long changes;

sclass Updatable {
  void update {}
  
  void setField(S field, O value) {
    if (eq(get(this, field), value)) ret;
    set(this, field, value);
    change();
  }
}

sclass Expectation {
  S ifClass;
  Runnable action;
  
  *() {}
  *(S *ifClass, Runnable *action) {}
}

sclass Word extends Updatable {
  S text; // or null if unknown
  Word prev, next;
  L<Word> constituents; // if group
  new L<Expectation> expectations;
  new L<Expectation> fulfilledExpectations;
  new TreeSet<S> classes;
  new LinkedHashSet<Word> groups; // I am part of
  
  void update {
    // Add direct word classes
    if (text != null)
      if (classes.addAll(reverseLookupInMapToSets(theSet, text))) change();
    
    // Make text for group  
    if (isGroup() && text == null) {
      L<S> l = collect(constituents, 'text);
      if (!anyNull(l)) setField(text := joinWithSpace(l));
    }
    
    // Process expectations
    for (Expectation e : cloneList(expectations)) {
      print("Checking expected class " + e.ifClass);
      if (classes.contains(e.ifClass)) {
        moveElementFromCollectionToCollection(e, expectations, fulfilledExpectations);
        change();
        callF(e.action);
      }
    }
  }
  
  bool isGroup() { ret constituents != null; }
  
  void addExpectation(Expectation e) {
    print("addExpectation " + e);
    expectations.add(e);
    change();
  }
}

static Word makeGroup(Word a, Word b) {
  print("makeGroup " + a.text + " / " + b.text);
  L<Word> list = ll(a, b);
  
  // look for existing group
  for (Word g : a.groups)
    if (eq(g.constituents, list))
      ret g;
      
  // new group
  new Word g;
  allObjects.add(g);
  change();
  g.constituents = list;
  for (Word w : list)
    w.groups.add(g);
  ret g;
}

sclass The extends Word {
  bool expectationSentToNext;
  
  void update {
    super.update();
    if (next != null && !expectationSentToNext) {
      final Word _next = next;
      _next.addExpectation(Expectation("<noun>", r {
        makeGroup(The.this, _next).classes.add("<noun>");
      }));
      set expectationSentToNext;
    }
  }
}

p-exp {
  S sentence = "In the movies Dracula always wears a cape";
  L<S> rawWords = printStruct(words(sentence));
  
  theSet = ai_englishWordCategoriesWithElements();
  
  new L<Word> words;
  for (S w : rawWords)
    words.add(nu(eqic(w, "the") ? The : Word, text := w));
  for (int i = 0; i < l(words)-1; i++)
    linkWords(words.get(i), words.get(i+1));
  //printStruct(first(words));
  
  addAll(allObjects, words);
  long lastChanges;
  do {
    lastChanges = changes;
    print(n2(changes, "change"));
    for (Updatable w : cloneList(allObjects))
      w.update();
  } while (lastChanges != changes);
  
  //for (Word w : words) printStruct(cloneForPrinting(w));
    
  L<Word> groups = [Word w : instancesOf(Word, allObjects) | w.constituents != null];
  print(n2(groups, "group"));
  for (Word g : groups)
    print("Group: " + sfu(cloneForPrinting(g)));
}

svoid linkWords(Word a, Word b) {
  a.next = b;
  b.prev = a;
}

static O cloneForPrinting(Word w) {
  ret cloneWithoutFields(w, 'prev, 'next, 'constituents);
}

svoid change() { ++changes; }