"reprlib" --- Implementação alternativa à "repr()"
**************************************************

**Código-fonte:** Lib/reprlib.py

======================================================================

The "reprlib" module provides a means for producing object
representations with limits on the size of the resulting strings. This
is used in the Python debugger and may be useful in other contexts as
well.

Este módulo fornece uma classe, uma instância e uma função.

class reprlib.Repr

   Classe que fornece serviços de formatação úteis na implementação de
   funções semelhantes à embutida "repr()"; limites de tamanho para
   diferentes tipos de objetos são adicionados para evitar a geração
   de representações excessivamente longas.

reprlib.aRepr

   Esta é uma instância de "Repr" que é usada para fornecer a função
   "repr()" descrita abaixo. Alterar os atributos deste objeto afetará
   os limites de tamanho usados por "repr()" e pelo depurador Python.

reprlib.repr(obj)

   Este é o método "repr()" de "aRepr". Ele retorna uma string
   semelhante à retornada pela função embutida de mesmo nome, mas com
   limites na maioria dos tamanhos.

In addition to size-limiting tools, the module also provides a
decorator for detecting recursive calls to "__repr__()" and
substituting a placeholder string instead.

@reprlib.recursive_repr(fillvalue="...")

   Decorator for "__repr__()" methods to detect recursive calls within
   the same thread.  If a recursive call is made, the *fillvalue* is
   returned, otherwise, the usual "__repr__()" call is made.  For
   example:

   >>> from reprlib import recursive_repr
   >>> class MyList(list):
   ...     @recursive_repr()
   ...     def __repr__(self):
   ...         return '<' + '|'.join(map(repr, self)) + '>'
   ...
   >>> m = MyList('abc')
   >>> m.append(m)
   >>> m.append('x')
   >>> print(m)
   <'a'|'b'|'c'|...|'x'>

   Novo na versão 3.2.


Objetos Repr
============

Instâncias "Repr" fornecem vários atributos que podem ser usados para
fornecer limites de tamanho para as representações de diferentes tipos
de objetos e métodos que formatam tipos de objetos específicos.

Repr.maxlevel

   Limite de profundidade na criação de representações recursivas. O
   padrão é "6".

Repr.maxdict
Repr.maxlist
Repr.maxtuple
Repr.maxset
Repr.maxfrozenset
Repr.maxdeque
Repr.maxarray

   Limites no número de entradas representadas para o tipo de objeto
   nomeado. O padrão é "4" para "maxdict", "5" para "maxarray" e "6"
   para os demais.

Repr.maxlong

   Número máximo de caracteres na representação para um inteiro. Os
   dígitos são omitidos a partir do meio. O padrão é "40".

Repr.maxstring

   Limite no número de caracteres na representação da string. Observe
   que a representação "normal" da string é usada como fonte de
   caracteres: se sequências de escape forem necessárias na
   representação, elas poderão ser distorcidas quando a representação
   for encurtada. O padrão é "30".

Repr.maxother

   Este limite é usado para controlar o tamanho de tipos de objetos
   para os quais nenhum método de formatação específico está
   disponível no objeto "Repr". Ele é aplicado de maneira semelhante a
   "maxstring". O padrão é "20".

Repr.repr(obj)

   O equivalente ao "repr()" embutido que usa a formatação imposta
   pela instância.

Repr.repr1(obj, level)

   Implementação recursiva usada por "repr()". Esta usa o tipo de
   *obj* para determinar qual método de formatação chamar, passando
   *obj* e *level*. Os métodos específicos de tipo devem chamar
   "repr1()" para realizar a formatação recursiva, com "level - 1"
   para o valor de *level* na chamada recursiva.

Repr.repr_TYPE(obj, level)

   Métodos de formatação para tipos específicos são implementados como
   métodos com um nome baseado no nome do tipo. No nome do método,
   **TYPE** é substituído por "'_'.join(type(obj).__name__.split())".
   O despacho para esses métodos é tratado por "repr1()". Métodos
   específicos de tipo que precisam formatar um valor recursivamente
   devem chamar "self.repr1(subobj, level - 1)".


Estendendo objetos Repr
=======================

The use of dynamic dispatching by "Repr.repr1()" allows subclasses of
"Repr" to add support for additional built-in object types or to
modify the handling of types already supported. This example shows how
special support for file objects could be added:

   import reprlib
   import sys

   class MyRepr(reprlib.Repr):

       def repr_TextIOWrapper(self, obj, level):
           if obj.name in {'<stdin>', '<stdout>', '<stderr>'}:
               return obj.name
           return repr(obj)

   aRepr = MyRepr()
   print(aRepr.repr(sys.stdin))         # prints '<stdin>'
