I promise that this is always a collection of HazeltaskTasks
195890
public Collection<HazeltaskTask<GROUP>> call() throws Exception {
        try {
            if(isShutdownNow)
                return this.getDistributedExecutorService().shutdownNowWithHazeltask();
            else
                this.getDistributedExecutorService().shutdown();
        } catch(IllegalStateException e) {}
        
        return Collections.emptyList();
    }
585878
function () {
    var routes = Array.prototype.slice.call(arguments);
    if (routes.length) {
      Ember.A(routes).forEach(function (child) {
        this._route(child);
      }, this);
    }
    else {
      if (!this.get('isResource')) {
        this.set('isResource', true);
      }
    }
    return this;
  }
793646
function waitAll() {
    return new Promise(function (resolved) {
        if (currentCount === 0 && remainedTasks.length === 0) {
            resolved();
        } else {
            waitAllCallbacks.push(resolved);
        }
    });
}
992748
function Collector(expected) {
  this.expectKeys = Array.isArray(expected) ? new Set(expected) : null;
  this.expected = this.expectKeys ? expected.length : expected;
  this.keys = new Set();
  this.count = 0;
  this.timer = null;
  this.onDone = common.emptiness;
  this.isDistinct = false;
  this.isDone = false;
  this.data = {};
}
568984
private <T> Collection<? extends Callable<T>> wrap(Collection<? extends Callable<T>> tasks) {
        List<Callable<T>> wrappedTasks = new ArrayList<Callable<T>>();
        Iterator<? extends Callable<T>> i = tasks.iterator();
        while (i.hasNext()) {
            Callable<T> c = wrap(i.next());
            if (serverStopping)
                wrappedTasks.add(c);
            else
                wrappedTasks.add(new CallableWrapper<T>(c));
        }
        return wrappedTasks;
    }
75208
public static function make(): CheckerCollection
    {
        $checkerCollection = new CheckerCollection();

        do_action(self::REGISTER_HOOK, $checkerCollection);
        do_action(self::BOOT_HOOK, $checkerCollection);

        return $checkerCollection;
    }
1211273
function Collection(response, dispatcher, dispatchOptions) {
  if (!Collection.isCollectionResponse(response)) {
    throw new Error(
        'Cannot create Collection from response that does not have resources');
  }

  this.data = response.data;
  this._response = response;
  this._dispatcher = dispatcher;
  this._dispatchOptions = dispatchOptions;
}
873247
def collections(self):
        """"""
        # if cache server is configured, load collection from there
        if self.cache:
            return self.cache.get(
                self.app.config['COLLECTIONS_CACHE_KEY'])
105076
@Override
    public RequestPromise<T> always(io.reinert.gdeferred.AlwaysCallback<T, Throwable> callback) {
        super.always(callback);
        return this;
    }
838979
function (collectionV1) {
        if (_.isEmpty(collectionV1 && collectionV1.requests)) { return; }

        var self = this;

        collectionV1.requests.forEach(function (request) {
            self.request(request);
        });

        return _.compact(collectionV1.requests);
    }
450300
function (callback) {
    var self = this;
    async.parallel([
      function (callback) {
        async.each(self.dispatcher.tree.getCollections(), function (col, callback) {
          if (col.noReplay) {
            return callback(null);
          }
          col.repository.clear(callback);
        }, callback);
      },
      function (callback) {
        self.store.clear(callback);
      }
    ], callback);
  }
334405
def unique(self):
        
        seen = set()
        seen_add = seen.add

        return Collection([x for x in self._items if not (x in seen or seen_add(x))])
357363
function watchTask() {
    gulp.watch(config.watchers.static, copyStaticFiles);
    gulp.watch(config.watchers.css, gulp.series(lintCSS, compileSass));
    gulp.watch(config.watchers.js, gulp.series(lintJS, concatJS, copyJS));
    gulp.watch(config.watchers.drizzle, drizzleTask);
}
918199
def forever(self, key, value):
        
        self._store.forever(self.tagged_item_key(key), value)
1332605
async def create_app_collections(db):
    ''' '''
    futures = []
    for model_class in MongoCollectionMixin.__subclasses__():
        if model_class._meta.concrete is True:
            futures.append(create_collection(db, model_class))

    await asyncio.gather(*futures)
845214
def always_win(cls, request) -> [(200, 'Ok', String)]:
        ''''''
        task_id = uuid4().hex.upper()[:5]
        log.info('Starting always OK task {}'.format(task_id))
        for i in range(randint(0, MAX_LOOP_DURATION)):
            yield
        log.info('Finished always OK task {}'.format(task_id))
        msg = 'I am finally done with task {}!'.format(task_id)
        Respond(200, msg)
1101503
function() {
    var collection = [];
    var scope = this;
    this.each(function() {
      var p = scope.parent(this[0]);
      if(p && p[0]) collection.push(p[0]);
    });
    return new SpahQL(collection);
  }