docs: def load_into(self, obj, data, inplace=True, *args, **kwargs):
          """Load data and update existing object.
  
          :param obj: Object to update with deserialized data.
          :param data: Raw data to get value to deserialize from.
          :param bool inplace: If True update data inplace;
              otherwise - create new data.
          :param kwargs: Same keyword arguments as for :meth:`Type.load`.
          :returns: Updated object.
          :raises: :exc:`~lollipop.errors.ValidationError`
          """
          if obj is None:
              raise ValueError('Load target should not be None')
  
          if data is MISSING:
              return
  
          if data is None:
              self._fail('required')
  
          if not is_mapping(data):
              self._fail('invalid', data=data)
  
          errors_builder = ValidationErrorBuilder()
  
          data1 = {}
          for name, field in iteritems(self.fields):
              try:
                  if name in data:
                      # Load new data
                      value = field.load_into(obj, name, data,
                                              inplace=not self.immutable and inplace,
                                              *args, **kwargs)
                  else:
                      # Retrive data from existing object
                      value = field.load(name, {
                          name: field.dump(name, obj, *args, **kwargs)
                      })
  
                  if value is not MISSING:
                      data1[name] = value
              except ValidationError as ve:
                  errors_builder.add_error(name, ve.messages)
  
          if self.allow_extra_fields is False:
              field_names = [name for name, _ in iteritems(self.fields)]
              for name in data:
                  if name not in field_names:
                      errors_builder.add_error(name, self._error_messages['unknown'])
          elif isinstance(self.allow_extra_fields, Field):
              field_names = [name for name, _ in iteritems(self.fields)]
              for name in data:
                  if name not in field_names:
                      try:
                          loaded = self.allow_extra_fields.load_into(
                              obj, name, data,
                              inplace=not self.immutable and inplace,
                              *args, **kwargs
                          )
                          if loaded != MISSING:
                              data1[name] = loaded
                      except ValidationError as ve:
                          errors_builder.add_error(name, ve.messages)
  
          errors_builder.raise_errors()
  
          data2 = super(Object, self).load(data1, *args, **kwargs)
  
          if self.immutable or not inplace:
              result = data2
              if self.constructor:
                  result = self.constructor(**result)
          else:
              for name, value in iteritems(data2):
                  field = self.fields.get(name, self.allow_extra_fields)
                  if not isinstance(field, Field):
                      continue
  
                  field.set_value(name, obj, value, *args, **kwargs)
  
              result = obj
  
          return result