docs: def enrich(self, expected=None, provided=None, path=None, validator=None):
          """ Enrich this error with additional information.
  
          This works with both Invalid and MultipleInvalid (thanks to `Invalid` being iterable):
          in the latter case, the defaults are applied to all collected errors.
  
          The specified arguments are only set on `Invalid` errors which do not have any value on the property.
  
          One exclusion is `path`: if provided, it is prepended to `Invalid.path`.
          This feature is especially useful when validating the whole input with multiple different schemas:
  
          ```python
          from good import Schema, Invalid
  
          schema = Schema(int)
          input = {
              'user': {
                  'age': 10,
              }
          }
  
          try:
              schema(input['user']['age'])
          except Invalid as e:
              e.enrich(path=['user', 'age'])  # Make the path reflect the reality
              raise  # re-raise the error with updated fields
          ```
  
          This is used when validating a value within a container.
  
          :param expected: Invalid.expected default
          :type expected: unicode|None
          :param provided: Invalid.provided default
          :type provided: unicode|None
          :param path: Prefix to prepend to Invalid.path
          :type path: list|None
          :param validator: Invalid.validator default
          :rtype: Invalid|MultipleInvalid
          """
          for e in self:
              # defaults on fields
              if e.expected is None and expected is not None:
                  e.expected = expected
              if e.provided is None and provided is not None:
                  e.provided = provided
              if e.validator is None and validator is not None:
                  e.validator = validator
              # path prefix
              e.path = (path or []) + e.path
          return self