How to use

chain

function

in

LoDashStatic

Promise
 .all([
  queryCollaborators({ repositoryOwner, repositoryName }),
  queryCommits({ repositoryOwner, repositoryName, since })
 ])
 .then(results => {
  const collaborators = _.keyBy(results[0], 'login')

  return _.chain(results[1])
   .map('author.user')
   .reject(_.isEmpty)
   .groupBy('login')
   .map(group => _.defaults({ commits: _.size(group) }, _.head(group)))
   .filter(user => _.isEmpty(collaborators[user.login]))
   .value()
 })
 .then(res => formatOutput(res))
 .catch(err => console.log(err))

_.chain(sentences)
  .map(function (sentence) {
   sentence['word_form_similarity'] = _.chain(sentences)
    .map(function (item) { return sim1(item['words'], sentence['words']) })
    .reduce(function(total, n) { return total + n })
    .value()
   return sentence
  })
  .value()

_.chain(best_sentences)
  .sortBy(function(a) { return a['s_id'] })
  .map('text')
  .value()
  .join(' ')

_.chain(count)
     .times()
     .transform((result, n) => {
      result[n] = new Bluebird((resolve) => setImmediate(resolve));
     }, {})
     .value()

Promise.all(semesters.map(function (semester) {
      return self.__getSemesterCourses__(semester);
    }
  )).then(function (coursesArray) {
    return _.chain(coursesArray).flatten().uniq(function (course) {
      return course.id;
    }).value();
  }, function (err) {
    return self.__getAllCoursesOffline__();
  })

var wssim = function (word, words) {
 if (_.isEmpty(words))
  return 0
 var max_similarity = _.chain(words)
  .map(function (w) { return similarity(word, w) })
  .max()
  .value()
 return max_similarity
}

_
   .chain(events)
   .map((event) => {
    const propertyName = getStringValueForSQL(event.propertyName);
    const propertyValue = getStringValueForSQL(event.propertyValue);
    return `(${event.eventId}, "${event.subscriptionType}", ${propertyName}, ${propertyValue}, ${event.objectId}, ${event.occurredAt})`
   })
   .join(',')
   .value()

_.chain(order)
    .flatten()
    .uniq()
    .sort()
    .map(key => ({
      key,
      done: false,
      deps: order.filter(([a, b]) => b === key)
        .map(d => d[0])
    }))
    .keyBy('key')
    .value()

_.chain(data)
    .map(aggregateData)
    .groupBy(aggData, function(singleRecord) { return singleRecord.Timestamp })
    .sortBy('Timestamp')
    .value()

_.chain(aggData[0])
    .map(function(item) {
      return item.Timestamp + ' ' + item.EventType;
    })
    .countBy(_.identity)
    .value()

_.chain(count)
     .times()
     .transform((result, n) => {
      result[n] = new Aigle((resolve) => resolve(n));
     }, {})
     .value()

_.chain(sentences)
  .map(function (sentence) {
   sentence['word_semantic_similarity'] = _.chain(sentences)
    .map(function (item) { return sim2(item['words'], sentence['words']) })
    .reduce(function(total, n) { return total + n })
    .value()
   return sentence
  })
  .value()

_.chain(count)
     .times()
     .transform((result, n) => {
      result[n] = new Bluebird((resolve) => resolve(n));
     }, {})
     .value()

_.chain(count)
     .times()
     .transform((result, n) => {
      result[n] = new Aigle((resolve) => setImmediate(resolve));
     }, {})
     .value()

Promise
 .all([
  queryCollaborators({ repositoryOwner, repositoryName }),
  queryCommits({ repositoryOwner, repositoryName, since })
 ])
 .then(results => {
  const collaborators = _.keyBy(results[0], 'login')

  return _.chain(results[1])
   .map('author.user')
   .reject(_.isEmpty)
   .groupBy('login')
   .map(group => _.defaults({ commits: _.size(group) }, _.head(group)))
   .filter(user => _.isEmpty(collaborators[user.login]))
   .value()
 })
 .then(res => formatOutput(res))
 .catch(err => console.log(err))