_________________________________________ EACH
772273
function(context, descriptor, args) {
		var path = args[0],
			values = (typeof path === 'string') ? context.get(path) : path;
		if (values && values.length) {
			var template = args[1];
			for (var i = 0, len = values.length; i < len; ++i)
				template.toHTMLString(new Context(values[i], context), descriptor);
		} else if (args[2])
			args[2].toHTMLString(context, descriptor);
	}
468913
function each(object, callback) {
  keys(object).forEach(function(key) {
                         callback(key, object[key], object) })}
336335
function (list, cb) {
            can.each(list, function (item, i) {
                cb(item, i, list)
            })
        }
1282577
def each(cmd_options={}, &block)
      all(cmd_options).each do |branch|
        block.call(branch)
      end
    end
376811
def each(&block)
      items = self.next.to_h['items']

      until items.empty?
        items.each(&block)
        items = self.next.to_h['items']
      end
    end
690589
def each
      return enum_for(:each) unless block_given?

      execute.each do |result|
        yield(model.new(result.merge(api: api)))
      end
    end
38077
def each(&block)
      (0...@buffer.count).each_slice(5000) do |linenos|
        start, stop = linenos[0], linenos[-1] + 1
        @buffer.get_lines(start, stop, true).each(&block)
      end
    end
113043
def each_child(&block)
      if block_given?
        block.call self

        @children.each do |_, child|
          child.each_child(&block)
        end
      end
    end
23488
def each_open
      self.each { |r, c, _| yield(r, c) if open?(r, c) }
    end
218555
def each
      loop do
        results.each do |result|
          yield(result)
        end
        go_next!
      end
    rescue UserEngage::NoNextPageAvailableException
      true
    end
66480
function each (obj, iterate, context) {
  if (obj) {
    context = context || this
    if (isArray(obj)) {
      return arrayEach(obj, iterate, context)
    }
    return objectEach(obj, iterate, context)
  }
  return obj
}
187950
function eachObject(obj, fn) {
                for (var k in obj) {
                    hasOwn(obj, k) && fn(obj[k], k, obj);
                }
                // ie6-8 enum bug
                if (hasEnumBug) {
                    for (var i = enumProperties.length - 1; i > -1; --i) {
                        var key = enumProperties[i];
                        hasOwn(obj, key) && fn(obj[key], key, obj);
                    }
                }
            }
275114
function each(seq, pred, ctx) {
        return sequencep(seq)?  __each.call(seq, pred, ctx)
             : /* non-seq */    undefined
    }
1057406
def each(&block)
      return @results.each(&block) if @results
      @results = []
      cur_v_i = Array.new(@data.keys.length, 0)
      keys = @data.keys.sort_by(&:to_s)
      result = {}
      keys.each do |key|
        result[key] = @data[key][0]
      end
      while true
        r = result.dup
        @results << r
        block.call(r) if block
        keys.each_with_index do |k, k_i|
          v_i = ((cur_v_i[k_i] = (1 + cur_v_i[k_i]) % @data[k].length))
          result[k] = @data[k][v_i]
          if v_i > 0 # Found next ?
            break
          elsif k_i == keys.length - 1 # Last?
            return
          end
        end
      end
      @results
    end
711876
function each(cursor, callback) {
  let Cursor = loadCursor();

  if (!callback) throw MongoError.create({ message: 'callback is mandatory', driver: true });
  if (cursor.isNotified()) return;
  if (cursor.s.state === Cursor.CLOSED || cursor.isDead()) {
    return handleCallback(
      callback,
      MongoError.create({ message: 'Cursor is closed', driver: true })
    );
  }

  if (cursor.s.state === Cursor.INIT) cursor.s.state = Cursor.OPEN;

  // Define function to avoid global scope escape
  let fn = null;
  // Trampoline all the entries
  if (cursor.bufferedCount() > 0) {
    while ((fn = loop(cursor, callback))) fn(cursor, callback);
    each(cursor, callback);
  } else {
    cursor.next((err, item) => {
      if (err) return handleCallback(callback, err);
      if (item == null) {
        return cursor.close({ skipKillCursors: true }, () => handleCallback(callback, null, null));
      }

      if (handleCallback(callback, null, item) === false) return;
      each(cursor, callback);
    });
  }
}
676019
function each(obj, iterator, context) {
    var i;

    if (!obj) {
        return;
    }

    if (obj.forEach) {
        obj.forEach(iterator, context);
    } else if (obj.length !== undefined) {
        i = 0;
        while (i < obj.length) {
            iterator.call(context, obj[i], i, obj);
            i++;
        }
    } else {
        for (i in obj) {
            obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);
        }
    }
}
1354873
function _each (result, callback, context, recordNum, resolve, reject) {
    // fetch more records
    result.fetch()
    // iterate over fetched records
    .then(records => {
        if (!records || !records.length) {
            return
        }
        // iterate over records
        return Promise.each(records, record => {
            // wait for callback to complete if it returns promise
            return callback(record, recordNum++, context)
        })
    })
    .then(() => {
        // resolve parent promise if done
        if (result.done) {
            resolve(context)
        }
        // iterate over more records if not all fetched
        else {
            _each(result, callback, context, recordNum, resolve, reject)
        }
    })
    // pass errors to parent promise
    .catch(reject)
}