abstract sclass Op extends F1 {}

sclass ApplySF extends Op {
  S name;
  int pos;
  L args;
  
  *() {}
  *(S *name) { args = ll(); }
  *(S *name, int *pos, O... args) { this.args = asList(args); }
  
  O get(O o) {
    L args = cloneList(this.args);
    args.add(pos, o);
    ret makeAndCall(name, toObjectArray(args));
  }
}

sclass ApplyFunc extends Op {
  S code;
  
  *() {}
  *(S code) { this.code = trim(code); }
  
  O get(O o) {
    ret evalFuncWithImportExport(code, o);
  }
}

sclass MapSF extends Op {
  Op op;

  *() {}
  *(Op *op) {}

  O get(O o) {
    ret map(op, (Collection) o);
  }
}

sclass Operation {
  Op op;
  Data result;
  
  *() {}
  *(Op *op) {}
}

sclass Data {
  O data;
  PersistableThrowable error;
  new L<Operation> operations;
  
  *() {}
  *(O *data) {}
}

static Data initial;

svoid printTree(Data data) {
  if (data == null) { print("-"); ret; }
  if (data.error != null) print("Error: " + data.error);
  else {
    print_noNL("Data: ");
    if (data.data instanceof Collection)
      print_noNL("[" + l(data.data) + "] ");
    else if (data.data instanceof S) {
      int n = numLines((S) data.data);
      if (n > 1) print_noNL("[" + n + " lines] ");
    }
    print(shorten(struct(data.data)));
  }
  print_threadIndentPlus();
  try {
    int i = 0;
    for (Operation op : data.operations) {
      print("Op " + (++i) + ": " + struct(op.op));
      printTree(op.result);
    }
  } finally {
    print_threadIndentMinus();
  }
}

static Data doOp(Data data, Op theOp) {
  Operation op = new Operation(theOp);
  data.operations.add(op);
  try {
    op.result = new Data(op.op.get(data.data));
  } catch e {
    op.result = nu(Data, error := persistableThrowable(e));
  }
  ret op.result;
}

Began life as a copy of #1008513