sclass MetaTransformer {
  sinterface StructureHandler {
    O transform(O o, IF1 recurse);
    void visit(O o, IVF1 recurse);
  }
  
  L<StructureHandler> structureHandlers;
  //bool keepUnknown; // assume true for now
  
  *() {}
  *(StructureHandler... handlers) { structureHandlers = asList(handlers); }
  
  // if f returns null, go through structure
  // if f returns an object, do not recurse into it
  O transform(IF1 f, O o) {
    ping();
    try object f.get(o);
    
    IF1 recurse = asFunction(f);
    fOr (StructureHandler h : structureHandlers) {
      ping();
      ifdef MetaTransformer_debug
        print("Calling structure handler " + h + " on " + o);
      endifdef
      try object h.transform(o, recurse);
    }
    
    //ret keepUnknown ? o : null;
    ret o;
  }
  
  // transform without result
  void visit(IVF1 f, O o) {
    ping();
    f.get(o);
    
    IVF1 recurse = x -> visit(f, x);
    fOr (StructureHandler h : structureHandlers) {
      ping();
      ifdef MetaTransformer_debug
        print("Calling structure handler " + h + " on " + o);
      endifdef
      h.visit(o, recurse);
    }
  }
  
  // lift transformer function to handle structures
  IF1 asFunction(IF1 f) {
    ret o -> transform(f, o);
  }
  
  // check if any element satisfies a predicate.
  // Note: might even be faster without the cancel point logic
  bool any(IPred pred, O o) {
    new Flag flag;
    withCancelPoint(cp ->
      visit(x -> { if (pred.get(x)) flag.raise(); cancelTo(cp); }, o)
    );
    ret flag.isUp();
  }
}