anchor.diff:  bool _noOpFilter(Project p) => true;
   
   /*=T*/ _takeLast/*<T>*/(/*=T*/ value, /*=T*/ element) => element;
  +
  +//const Object _marker = const Object();
  +
  +Combiner/*<T>*/ _combinerToFold/*<T>*/(Combiner/*<T>*/ combiner) {
  +  var/*=T*/ firstValue;
  +  bool seenFirst = false;
  +  bool seenSecond = false;
  +  return (/*=T*/ value, /*=T*/ element) {
  +    if (!seenFirst) {
  +      seenFirst = true;
  +      firstValue = element;
  +      return firstValue;
  +    } else {
  +      if (!seenSecond) {
  +        seenSecond = true;
  +        return combiner(firstValue, element);
  +      } else {
  +        return combiner(value, element);
  +      }
  +    }
  +//    return element != _marker ? combiner(value, element) :
  +  };
  +}
  
positive.code:       {ProjectFilter filter, Combiner/*<T>*/ combine}) async {
      return new Stream/*<T>*/ .fromFutures(
              _filteredDepthFirst(filter).map/*<Future<T>>*/(command))
          .reduce(combine ?? _takeLast) as Future/*<T>*/;
  //    return (await Future.wait(_filteredDepthFirst(filter).map(command)))
  //        .reduce(combine ?? _takeLast);
    }
  
    Future/*<T>*/ processAllSerially/*<T>*/(ProjectFunction/*<T>*/ command,
  
negative.code:     return await new Stream<JefeProject>.fromIterable(
              _filteredDepthFirst(filter))
          .asyncMap((JefeProject p) => command(p))
          .fold(null, _combinerToFold(combine ?? _takeLast)) as Future/*<T>*/;
  //    return await Future.forEach(
  //        _filteredDepthFirst(filter), (JefeProject p) => command(p));
    }
  