docs: def _inf_or_operator_handler_factory(c_start, is_delegate=True):
      """Generates handler co-routines for values that may be `+inf` or `-inf`.
  
      Args:
          c_start (int): The ordinal of the character that starts this token (either `+` or `-`).
          is_delegate (bool): True if a different handler began processing this token; otherwise, False. This will only
              be true for `-inf`, because it is not the only value that can start with `-`; `+inf` is the only value
              (outside of a s-expression) that can start with `+`.
      """
      @coroutine
      def inf_or_operator_handler(c, ctx):
          next_ctx = None
          if not is_delegate:
              ctx.value.append(c_start)
              c, self = yield
          else:
              assert ctx.value[0] == c_start
              assert c not in _DIGITS
              ctx.queue.unread(c)
              next_ctx = ctx
              _, self = yield
              assert c == _
          maybe_inf = True
          ctx.set_ion_type(IonType.FLOAT)
          match_index = 0
          trans = ctx.immediate_transition(self)
          while True:
              if maybe_inf:
                  if match_index < len(_INF_SUFFIX):
                      maybe_inf = c == _INF_SUFFIX[match_index]
                  else:
                      if _ends_value(c) or (ctx.container.ion_type is IonType.SEXP and c in _OPERATORS):
                          yield ctx.event_transition(
                              IonEvent, IonEventType.SCALAR, IonType.FLOAT, c_start == _MINUS and _NEG_INF or _POS_INF
                          )
                      else:
                          maybe_inf = False
              if maybe_inf:
                  match_index += 1
              else:
                  ctx.set_unicode()
                  if match_index > 0:
                      next_ctx = ctx.derive_child_context(ctx.whence)
                      for ch in _INF_SUFFIX[0:match_index]:
                          next_ctx.value.append(ch)
                  break
              c, self = yield trans
          if ctx.container is not _C_SEXP:
              _illegal_character(c, next_ctx is None and ctx or next_ctx,
                                 'Illegal character following %s.' % (_chr(c_start),))
          if match_index == 0:
              if c in _OPERATORS:
                  yield ctx.immediate_transition(_operator_symbol_handler(c, ctx))
              yield ctx.event_transition(IonEvent, IonEventType.SCALAR, IonType.SYMBOL, ctx.value.as_symbol())
          yield _CompositeTransition(
              ctx.event_transition(IonEvent, IonEventType.SCALAR, IonType.SYMBOL, ctx.value.as_symbol()),
              ctx,
              partial(_unquoted_symbol_handler, c),
              next_ctx
          )
      return inf_or_operator_handler