anchor.diff:        Combiner/*<T>*/ combine,
         CommandConcurrencyMode mode: CommandConcurrencyMode.concurrentCommand}) {
       final processor =
  -        _processor(mode ?? CommandConcurrencyMode.concurrentCommand);
  +        _processor/*<T>*/(mode ?? CommandConcurrencyMode.concurrentCommand);
   
       return executeTask/*<T>*/(
           taskDescription,
  
positive.code: 
  typedef Future<S> SingleProjectCommandFactory<S>(JefeProject project);
  typedef Future<T> SingleProjectCommand<S, T>(S single);
  typedef Callable<T> _Processor<T>(
      String taskDescription, ProjectFunction/*<T>*/ command,
      {ProjectFilter filter, Combiner/*<T>*/ combine});
  
  abstract class BaseCommandsImpl<S> {
  
negative.code:           {ProjectFilter filter, Combiner/*<T>*/ combine}) =>
        graph.processDepthFirst(command, filter: filter, combine: combine);
  
    Callable/*<T>*/ _concurrentProcessor/*<T>*/(ProjectFunction/*<T>*/ command,
        {ProjectFilter filter, Combiner/*<T>*/ combine}) {
      return () =>
          graph.processAllConcurrently(command, filter: filter, combine: combine);
    }
  
    _Processor/*<T>*/ _processor/*<T>*/(CommandConcurrencyMode mode) {
      switch (mode) {
        case CommandConcurrencyMode.concurrentCommand:
        case CommandConcurrencyMode.concurrentProject:
        default:
          return _concurrentProcessor;
  //  case CommandConcurrencyMode.serial:
  //  return _concurrentProcessor;
      }
    }
  
  