How to use

map

function

in

CollectionChain

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

/**
 * Parse a rank result from redis
 * @param  {array} rank In this format: [ 'foo', '39', 'bar', '13' ]
 * @return {object} In this format: [ { foo: 39 }, { bar: 13 } ]
 * @private
 */
const rankParser = rank => {
 return _.chain(rank)
  .chunk(2)
  .map(([key, count]) => ({ [key]: Number(count) }))
  .value();
}

_.chain(_ids)
   .map(_id => _.find(db, a => a._id === _id))
   .tap(ids => console.log(ids))
   .compact()
   .each(a => a.retired = false)
   .value()

var getVC = function (words, join_words) {
 var words_trigram = getTrigram(words)
 var join_words_trigram = getTrigram(join_words)
 var result = _.chain(join_words_trigram)
  .map(function (word) { return (_.includes(words_trigram, word)) ? 1 : 0})
  .value()
 return result
}

_.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(suffix)
  .map(function (s) {
   var suffix = s
   var result = ''
   var limit = word.length-suffix.length
   if (word.lastIndexOf(suffix) == limit)
    result = word.substring(0, limit)
   return result
  })
  .filter(function (c) { return c !== '' })
  .filter(function (c) { return Word.prototype.isBasicWord(c) })
  .value()

_.chain(os.networkInterfaces())
  .values()
  .flatten()
  .filter(function(val) {
   return (val.family == 'IPv4' && val.internal == false)
  })
  .map('address')
  .first()
  .value()

_.chain(guards)
    .map(id => {
      const guard = state[id]
      return _.chain(guard.byMinute)
        .map((v, i) => ({v, i, id}))
        .maxBy('v')
        .value()
    })
    .maxBy('v')
    .value()

_.chain(coords)
    .filter(({z}) => !infinites.includes(z))
    .map(({z}) => data.match(new RegExp(z, 'g')).length)
    .sort((a, b) => a - b)
    .max()

indices() {
  return _.chain(this.fields)
   .filter('index')
   .map(({ name, index }) => {
    return {
     field: name,
     unique: _.isObject(index) && !!index.unique
    };
   })
   .value();
 }

var getVB = function (words, join_words) {
 var words_bigram = getBigram(words)
 var join_words_bigram = getBigram(join_words)
 var result = _.chain(join_words_bigram)
  .map(function (word) { return (_.includes(words_bigram, word)) ? 1 : 0})
  .value()
 return result
}

_.chain(events)
    .map('guard')
    .filter()
    .uniq()
    .map(id => ({
      id,
      asleep: false,
      minutesAsleep: 0,
      byMinute: _.range(60)
        .map(() => 0)
    }))
    .keyBy('id')
    .value()

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

_.chain(input)
    .map(i => i.match(/\[(\d+)-(\d+)-(\d+) (\d+):(\d+)] (Guard|falls|wakes) #?(\d+)?/))
    .map(([, year, month, day, hour, minute, action, guard]) => ({
        guard,
        month: +month,
        day: +day,
        hour: +hour,
        minute: +minute,
        action
      }
    ))
    .orderBy(['month', 'day', 'hour', 'minute'])
    .value()

_.chain(guard.byMinute)
    .map((v, i) => ({v, i}))
    .maxBy('v')
    .value()