yield to each key value pair
543444
def each
      index = 0
      while index < i_keys.get_length
        key = i_keys.get(index)
        value = i_values.get(index)
        yield key , value
        index = index + 1
      end
      self
    end
1156696
def keys(self) -> Iterator[str]:
        """"""
        if self.param:
            yield self.param_name
        yield from self.paths.keys()
682554
def each
      if @header
        @header.each{|k, v|
          value = @header[k]
          yield(k, value.empty? ? nil : value.join(", "))
        }
      end
    end
315591
function eachFrom(keys, key, iter) {
  var i = keys.indexOf(key)
  if(!~i) return
  //start at 1 because we want to visit all keys but key.
  for(var j = 1; j < keys.length; j++)
    if(iter(keys[(j+i)%keys.length], j))
      return
}
995444
def iterkeys(self):
        """"""
        def _iterkeys(bin):
            for item in bin:
                yield item.key

        for bin in self.bins:
            yield _iterkeys(bin)
680720
def _iter_vals(key):
    
    for i in range(winreg.QueryInfoKey(key)[1]):
        yield winreg.EnumValue(key, i)
211631
def pairwise(values):
    
    i = iter(values)
    a = next(i)

    for b in i:
        yield (a, b)
        a = b
420960
def _AtLeaf(self, attr_value):
    """"""
    if isinstance(attr_value, collections.Mapping):
      # If the result is a dict, return each key/value pair as a new dict.
      for k, v in iteritems(attr_value):
        yield {k: v}
    else:
      yield attr_value
166307
def chunks(iterable, chunk):
    """"""
    for i in range(0, len(iterable), chunk):
        yield iterable[i:i + chunk]
34752
def join(iterable, sep):
    """"""
    i = 0
    for i, item in enumerate(iterable):
        if i == 0:
            yield item
        else:
            yield sep
            yield item
651639
def chain(cls, *iterables):
    

    def generator():
      for it in iterables:
        for element in it:
          yield element
    return cls(generator())
1183648
def items(self, section):
        """"""
        for line in self.iter_lines(section):
            if line.kind == ConfigLine.KIND_DATA:
                yield line.key, line.value
914904
def each
      return to_enum unless block_given?
      seen = {}
      tuples.each do |tuple|
        tuple = Tuple.coerce(header, tuple)
        yield seen[tuple] = tuple unless seen.key?(tuple)
      end
      self
    end
525401
def traverse(nesting=[], &block)
      each_value do |config|
        if config.type.kind_of?(NestType)
          nesting.push config
          configs = config.type.configurable.class.configs
          configs.traverse(nesting, &block)
          nesting.pop
        else
          yield(nesting, config)
        end
      end
    end
1114364
def each(options = {}, &block)
      method = options[:reverse] ? :reverse_each : :each
      @set.sort_by(&:weight).send(method) do |item|
        if item.is_a?(ActiveScaffold::DataStructures::ActionLinks) && !options[:groups]
          item.each(options, &block)
        elsif options[:include_set]
          yield item, @set
        else
          yield item
        end
      end
    end
1020735
def iteritems(cls):
        
        for key in dir(cls):
            val = getattr(cls, key)
            if isinstance(cls, val):
                yield (key, val)
659519
def iteritems(self):
        ''''''
        for x in range(len(self.keys)):
            yield (self.keys[x], self.values[x])