code: def _mapFuture(callable_, *iterables):
      
      childrenList = []
      for args in zip(*iterables):
          childrenList.append(submit(callable_, *args))
      return childrenList
docs: Similar to the built-in map function, but each of its
      iteration will spawn a separate independent parallel Future that will run
      either locally or remotely as `callable(*args)`.
  
      :param callable: Any callable object (function or class object with *__call__*
          method); this object will be called to execute each Future.
      :param iterables: A tuple of iterable objects; each will be zipped
          to form an iterable of arguments tuples that will be passed to the
          callable object as a separate Future.
  
      :returns: A list of Future objects, each corresponding to an iteration of
          map.
  
      On return, the Futures are pending execution locally, but may also be
      transfered remotely depending on global load. Execution may be carried on
      with any further computations. To retrieve the map results, you need to
      either wait for or join with the spawned Futures. See functions waitAny,
      waitAll, or joinAll. Alternatively, You may also use functions mapWait or
      mapJoin that will wait or join before returning.