docs: def process_without_storing(d_vals, s_f_strm, s_f_key, output_type, outfh,
                              f_f_header=None, s_f_has_header=False,
                              missing_val=None, delim=None,
                              ignore_missing_keys=False,
                              output_unpaired=False, verbose=False):
    """
      Given a dictionary of values and (optionally) a header for a file,
      join with another file with a linear pass that does not store The
      file's values
  
      :param d_vals: dictionary of key-value pairs to match up with the lines
                     in the second file. If header_f1 is None, the values should
                     be ordered iterables --output will be in presentation order.
                     If f1_header is not None, values should be dictionary-like
                     objects accessible via a keys --output will be in the order
                     that the keys appear in header_f1
      :param s_f_strm: TODO
      :param s_f_key: TODO
      :param header: TODO
      :param f2_has_header: TODO
      :param missing_val: TODO
      :param verbose: TODO
    """
    used_d_val_keys = set()
    key_field_num = s_f_key
    s_f_header = None
    seen_keys = set()
    out_handler = output_type.get_handler()
    expected_cols_per_line = None
    first_element = True
    for line in file_iterator(s_f_strm, verbose):
      parts = __populated_missing_vals(line.split(delim), missing_val)
  
      # on the first element, we might have to output a header..
      if first_element:
        regular_first, s_f_header, key_field_num =\
            process_without_storing_header(parts, d_vals, f_f_header,
                                           s_f_has_header, s_f_header, s_f_key,
                                           key_field_num, out_handler, outfh,
                                           missing_val, delim)
  
      # any line that is either not the first, or is the first but we decided
      # it wasn't a header line...
      if not first_element or regular_first:
        if expected_cols_per_line is None:
          expected_cols_per_line = (len(parts) if s_f_header is None
                                    else len(s_f_header))
        if expected_cols_per_line != len(parts):
          raise RaggedInputError("Found line with " + str(len(parts)) + " "
                                 "columns, but was expecting " +
                                 str(expected_cols_per_line) + " columns")
  
        key_val = get_key_value(parts, key_field_num, ignore_missing_keys,
                                seen_keys, output_type)
        if key_val is None and ignore_missing_keys:
          continue
        seen_keys.add(key_val)
  
        if key_val not in d_vals:
          if not output_unpaired:
            continue
          f_f_flds = populate_unpaired_line(d_vals, f_f_header, missing_val)
        else:
          f_f_flds = d_vals[key_val]
          used_d_val_keys.add(key_val)
        s_f_flds = ([dict(zip(s_f_header, parts))]
                    if s_f_header is not None else [parts])
        out_handler.write_output(outfh, delim, s_f_flds, f_f_flds,
                                 s_f_header, f_f_header)
      first_element = False
  
    if output_unpaired:
      __output_unpaired_vals(d_vals, used_d_val_keys, f_f_header, s_f_flds,
                             s_f_header, missing_val, out_handler, outfh, delim)