docs: def merge(self):
          """Populates result members.
  
          Performs the merge algorithm using the specified config and fills in
          the members that provide stats about the merging procedure.
  
          Attributes:
              merged_root: The result of the merge.
  
              aligned_root, aligned_head, aligned_update: Copies of root, head
                  and update in which all matched list entities have the same
                  list index for easier diff viewing.
  
              head_stats, update_stats: Stats for each list field present in the
                  head or update objects. Instance of
                  :class:`json_merger.stats.ListMatchStats`
  
              conflicts: List of :class:`json_merger.conflict.Conflict` instances
                  that occured during the merge.
  
          Raises:
              :class:`json_merger.errors.MergeError` : If conflicts occur during
                  the call.
  
          Example:
              >>> from json_merger import Merger
              >>> # We compare people by their name
              >>> from json_merger.comparator import PrimaryKeyComparator
              >>> from json_merger.config import DictMergerOps, UnifierOps
              >>> from json_merger.errors import MergeError
              >>> # Use this only for doctest :)
              >>> from pprint import pprint as pp
              >>>
              >>> root = {'people': [{'name': 'Jimmy', 'age': 30}]}
              >>> head = {'people': [{'name': 'Jimmy', 'age': 31},
              ...                    {'name': 'George'}]}
              >>> update = {'people': [{'name': 'John'},
              ...                      {'name': 'Jimmy', 'age': 32}]}
              >>>
              >>> class NameComparator(PrimaryKeyComparator):
              ...     # Two objects are the same entitity if they have the
              ...     # same name.
              ...     primary_key_fields = ['name']
              >>> m = Merger(root, head, update,
              ...            DictMergerOps.FALLBACK_KEEP_HEAD,
              ...            UnifierOps.KEEP_UPDATE_AND_HEAD_ENTITIES_HEAD_FIRST,
              ...            comparators = {'people': NameComparator})
              >>> # We do a merge
              >>> try:
              ...     m.merge()
              ... except MergeError as e:
              ...     # Conflicts are the same thing as the exception content.
              ...     assert e.content == m.conflicts
              >>> # This is how the lists are aligned:
              >>> pp(m.aligned_root['people'], width=60)
              ['#$PLACEHOLDER$#',
               {'age': 30, 'name': 'Jimmy'},
               '#$PLACEHOLDER$#']
              >>> pp(m.aligned_head['people'], width=60)
              ['#$PLACEHOLDER$#',
               {'age': 31, 'name': 'Jimmy'},
               {'name': 'George'}]
              >>> pp(m.aligned_update['people'], width=60)
              [{'name': 'John'},
               {'age': 32, 'name': 'Jimmy'},
               '#$PLACEHOLDER$#']
              >>> # This is the end result of the merge:
              >>> pp(m.merged_root, width=60)
              {'people': [{'name': 'John'},
                          {'age': 31, 'name': 'Jimmy'},
                          {'name': 'George'}]}
              >>> # With some conflicts:
              >>> pp(m.conflicts, width=60)
              [('SET_FIELD', ('people', 1, 'age'), 32)]
              >>> # And some stats:
              >>> pp(m.head_stats[('people',)].in_result)
              [{'age': 31, 'name': 'Jimmy'}, {'name': 'George'}]
              >>> pp(m.update_stats[('people',)].not_in_result)
              []
  
          Note:
              Even if conflicts occur, merged_root, aligned_root, aligned_head
              and aligned_update are always populated by following the
              startegies set for the merger instance.
          """
          self.merged_root = self._recursive_merge(self.root, self.head,
                                                   self.update)
          if self.conflicts:
              raise MergeError('Conflicts Occurred in Merge Process',
                               self.conflicts)