@spin_after<EOL><INDENT>def map(self, f, *sequences, **kwargs):<DEDENT>
block = kwargs.pop('<STR_LIT>', self.block)<EOL>for k in list(kwargs.keys()):<EOL><INDENT>if k not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise TypeError("<STR_LIT>"%k)<EOL><DEDENT><DEDENT>assert len(sequences) > <NUM_LIT:0>, "<STR_LIT>"<EOL>pf = ParallelFunction(self, f, block=block, **kwargs)<EOL>return pf.map(*sequences)<EOL>
view.map(f, *sequences, block=self.block) => list|AsyncMapResult

        Parallel version of builtin `map`, using this View's `targets`.

        There will be one task per target, so work will be chunked
        if the sequences are longer than `targets`.

        Results can be iterated as they are ready, but will become available in chunks.

        Parameters
        ----------

        f : callable
            function to be mapped
        *sequences: one or more sequences of matching length
            the sequences to be distributed and passed to `f`
        block : bool
            whether to wait for the result or not [default self.block]

        Returns
        -------

        if block=False:
            AsyncMapResult
                An object like AsyncResult, but which reassembles the sequence of results
                into a single list. AsyncMapResults can be iterated through before all
                results are complete.
        else:
            list
                the result of map(f,*sequences)