docs: def generate_repr(*members):
      """
      Decorator that binds an auto-generated ``__repr__()`` function to a class.
  
      The generated ``__repr__()`` function prints in following format:
      <ClassName object(field1=1, field2='A string', field3=[1, 2, 3]) at 0xAAAA>
  
      Note that this decorator modifies the given class in place!
  
      :param members:         An iterable of member names to include into the
                              representation-string. Providing no members yields
                              to inclusion of all member variables and properties
                              in alphabetical order (except if they start with an
                              underscore).
  
                              To control the representation of each member, you
                              can also pass a tuple where the first element
                              contains the member to print and the second one the
                              representation function (which defaults to the
                              built-in ``repr()``). Using None as representation
                              function is the same as using ``repr()``.
  
                              Supported members are fields/variables, properties
                              and getter-like functions (functions that accept no
                              arguments).
      :raises ValueError:     Raised when the passed
                              (member, repr-function)-tuples have not a length of
                              2.
      :raises AttributeError: Raised when a given member/attribute was not found
                              in class.
      :raises TypeError:      Raised when a provided member is a bound method
                              that is not a getter-like function (means it must
                              accept no parameters).
      :return:                The class armed with an auto-generated __repr__
                              function.
      """
      def decorator(cls):
          cls.__repr__ = __repr__
          return cls
  
      if members:
          # Prepare members list.
          members_to_print = list(members)
          for i, member in enumerate(members_to_print):
              if isinstance(member, tuple):
                  # Check tuple dimensions.
                  length = len(member)
                  if length == 2:
                      members_to_print[i] = (member[0],
                                             member[1] if member[1] else repr)
                  else:
                      raise ValueError("Passed tuple " + repr(member) +
                                       " needs to be 2-dimensional, but has " +
                                       str(length) + " dimensions.")
              else:
                  members_to_print[i] = (member, repr)
  
          def __repr__(self):
              return _construct_repr_string(self, members_to_print)
      else:
          def __repr__(self):
              # Need to fetch member variables every time since they are unknown
              # until class instantation.
              members_to_print = get_public_members(self)
  
              member_repr_list = ((member, repr) for member in
                                  sorted(members_to_print, key=str.lower))
  
              return _construct_repr_string(self, member_repr_list)
  
      return decorator