docs: def pretty_call_alt(ctx, fn, args=(), kwargs=()):
      """Returns a Doc that represents a function call to :keyword:`fn` with
      the ``args`` and ``kwargs``.
  
      Given an arbitrary context ``ctx``,::
  
          pretty_call_alt(ctx, sorted, args=([7, 4, 5], ), kwargs=[('reverse', True)])
  
      Will result in output::
  
          sorted([7, 4, 5], reverse=True)
  
      The layout algorithm will automatically break the call to multiple
      lines if needed::
  
          sorted(
              [7, 4, 5],
              reverse=True
          )
  
      ``pretty_call_alt`` automatically handles syntax highlighting.
  
      :param ctx: a context value
      :type ctx: prettyprinter.prettyprinter.PrettyContext
      :param fn: a callable
      :param args: a ``tuple`` of positional arguments to render to the call
      :param kwargs: keyword arguments to render to the call. Either an instance
                     of ``OrderedDict``, or an iterable of two-tuples, where the
                     first element is a `str` (key), and the second is the Python
                     value for that keyword argument.
      :returns: :class:`~prettyprinter.doc.Doc`
      """
  
      fndoc = general_identifier(fn)
  
      if ctx.depth_left <= 0:
          return concat([fndoc, LPAREN, ELLIPSIS, RPAREN])
  
      if not kwargs and len(args) == 1:
          sole_arg = args[0]
          unwrapped_sole_arg, _comment, _trailing_comment = unwrap_comments(args[0])
          if type(unwrapped_sole_arg) in (list, dict, tuple):
              return build_fncall(
                  ctx,
                  fndoc,
                  argdocs=[pretty_python_value(sole_arg, ctx)],
                  hug_sole_arg=True,
              )
  
      nested_ctx = (
          ctx
          .nested_call()
          .use_multiline_strategy(MULTILINE_STRATEGY_HANG)
      )
  
      if not DICT_KEY_ORDER_SUPPORTED and isinstance(kwargs, dict):
          warnings.warn(
              "A dict was passed to pretty_call_alt to represent kwargs, "
              "but Python 3.5 doesn't maintain key order for dicts. The order "
              "of keyword arguments will be undefined in the output. "
              "To fix this, pass a list of two-tuples or an instance of "
              "OrderedDict instead.",
              UserWarning
          )
  
      kwargitems = (
          kwargs.items()
          if isinstance(kwargs, (OrderedDict, dict))
          else kwargs
      )
  
      return build_fncall(
          ctx,
          fndoc,
          argdocs=(
              pretty_python_value(arg, nested_ctx)
              for arg in args
          ),
          kwargdocs=(
              (kwarg, pretty_python_value(v, nested_ctx))
              for kwarg, v in kwargitems
          ),
      )