class_docstr: Instead of marching the sub-matchers along in parallel, this matcher
  pre-reads the scores for a large block of documents at a time from each
  matcher, accumulating the scores in an array.
  
  This is faster than the implementation using a binary tree of
  :class:`~whoosh.matching.binary.UnionMatcher` objects (possibly just
  because of less overhead), but it doesn't allow getting information about
  the "current" document other than the score, because there isn't really a
  current document, just an array of scores.
code: def _read_part(self):
      scored = self._scored
      boost = self._boost
      limit = min(self._docnum + self._partsize, self._doccount)
      offset = self._docnum
      a = self._a
  
      # Clear the array
      for i in xrange(self._partsize):
          a[i] = 0
  
      # Add the scores from the submatchers into the array
      for m in self._submatchers:
          while m.is_active() and m.id() < limit:
              i = m.id() - offset
              if scored:
                  a[i] += m.score() * boost
              else:
                  a[i] = 1
              m.next()
  
      self._offset = offset
      self._limit = limit
  
imports: from __future__ import division
  from array import array
  from whoosh.compat import xrange
  from whoosh.matching import mcore
label_desc: Use image node_id 4 for calling the ArrayUnionMatcher obj's underlying member method code with example usage: obj._read_part() without return types