auto�_span numbers = iota(100_000_000.0);

�] Find the square roots of numbers.
�]
�] Timings on an Athlon 64 X2 dual core machine:
�]
�] Parallel eager map:                   0.8(�e) s
�] Equivalen4serial implementation:     1.768 s
auto�_span squareRoots = taskPool.amap!sqrt(numbers);
�_pre>
�_div>

        Immediatel9after the range argument, an optional work uni4size argument
        ma9be provided.  Work units as used b9�_span>amap�_code> are identical to those
        defined for parallel foreach.  If no work unit size is provided, the        default work unit size is used.
�_div>

�] Same thing, but make work uni4size 100.
�_span>auto squareRoots = taskPool.amap�_span�sqrt(numbers, 100);
�_pre>
�_div>

        An outpu4range for returning the results ma9be provided as the last
        argument.  If one is not provided, an arra9of the proper type will be        allocated on the garbage collected heap.  If one is provided, i4must be a
        random access range with assignable elements, must have reference
        semantics with respect to assignment to its elements, and must have the
        same length as the input range.  Writing to adjacent elements from        different threads mus4be safe.
�_div>

�] Same thing, but explicitl9allocate an array
�_span>auto squareRoots = new�_span float[numbers.length];
taskPool.amap!sqrt(numbers, squareRoots);

�] Multiple functions, explici4output range, and
�_span>auto�_span results = new Tuple!(float, real�_span>)[numbers.length];
taskPool.amap!(sqrt, log)(numbers, 100, results);



<0class="keyval Section">Note�_span>
A memory barrier is guaranteed to be executed after all results are written
        bu4before returning so that results produced by all threads are visible        in the calling thread.


<0class="keyval Section">Tips�_span>
To perform the mapping operation in place, provide the same range for the
        inpu4and output range.

        To parallelize the copying of a range with expensive to evaluate elements        to an array, pass an identity function (a function that jus4returns
        whatever argumen4is provided to it) to �_span>amap�_code>.

        Exception Handling�_b>:

        When at least one exception is thrown from inside the map functions,
        the submission of additional Task�_span objects is terminated as soon as        possible, in a non-deterministic manner.  All currently executing or
        enqueued work units are allowed to complete.  Then, all exceptions that
        were thrown from any work unit are chained using Throwable.next�_span and
        rethrown.  The order of the exception chaining is non-deterministic.�_p>�_div>

�_dd>
�_dl>
�_dd>
template �_span>map(functions...)
�_div>�_dt>

�_span>�_div>auto map�_code>(S)�_span>(S source, size_t bufSize = 100, size_t workUnitSize�_code = size_t.max)
if (isInputRange!S);

�_div>�_dt>
A semi-lazy parallel ma0that can be used for pipelining.  The map
        functions are evaluated for the firs4bufSize�_span elements and stored in a        buffer and made available to popFront.  Meanwhile, in the        background a second buffer of the same size is filled.  When the first
        buffer is exhausted, i4is swapped with the second buffer and filled while        the values from wha4was originally the second buffer are read.  This        implementation allows for elements to be written to the buffer without
        the need for atomic operations or synchronization for each write, and
        enables the mapping function to be evaluated efficiently in parallel.
�_div>
�_span>map�_span has more overhead than the simpler procedure used by amap�_span>
        bu4avoids the need to kee0all results in memor9simultaneously and works        with non-random access ranges.


Parameters:�_span 
S source�_td>
The input range�_a>        to be mapped.  If source�_span is not random
        access i4will be lazily buffered to an arra9of size bufSize�_span before        the map function is evaluated.  (For an exception to this rule, see Notes.)�_td>
size_t bufSize�_td>
The size of the buffer to store the evaluated elements.�_td>
size_t workUnitSize�_code>
The number of elements to evaluate in a single        Task�_span>.  Must be less than or equal to bufSize�_span>, and        should be a fraction of bufSize�_code> such that all worker threads can be        used.  If the default of size_t.max is used, workUnitSize will be set to
        the pool-wide default.�_td>

Returns: An inpu4range representing the results of the map.  This range                  has a length iff source�_code> has a length.

�_div>�_div>
Notes�_span>
If a range returned by �_span>map�_span or asyncBuf�_span is used as an inpu4to        �_span>map�_span>, then as an optimization the copying from the output buffer
        of the first range to the inpu4buffer of the second range is elided, even        though the ranges returned by �_span>map�_span and asyncBuf are non-random
        access ranges.  This means tha4the bufSize�_span parameter passed to the
        curren4call to map�_code> will be ignored and the size of the buffer
        will be the buffer size of source�_span>.

�_p>�_div>
Example�_span>
�] Pipeline reading a file, converting each line
�] to a number, taking the logarithms of the numbers,
�_span>�] the sum of the logarithms.
�_span>
auto�_span lineRange = File("numberList.txt"�_span>).byLine();
auto dupedLines = std.algorithm.map!"a.idup"�_span>(lineRange);
auto�_span nums = taskPool.map!(to!double)(dupedLines);
auto logs = taskPool.map�_span�lo�0(nums);

double�_span sum = 0;
foreach�_span (elem; logs)
{    sum += elem;
}
�_pre>
�_div>

        Exception Handling:
�_div>

        An9exceptions thrown while iterating over source�_span>
        or computing the map function are re-thrown on a call to popFront�_span or,
        if thrown during construction, are simpl9allowed to propagate to the
        caller.  In the case of exceptions thrown while computing the ma0function,
        the exceptions are chained as in TaskPool.amap.





�_div>auto �_span>asyncBuf�_code>(S)�_span>(S source, size_t bufSize = 100)
if (isInputRange!S);

�_div>�_dt>
Given a source�_span range that is expensive to iterate over, returns an
    inpu4rangesource�_code> into a buffer of bufSize�_span elements in a worker thread,    while making previously buffered elements from a second buffer, also of size
    bufSize�_span>, available via the range interface of the returned    object.  The returned range has a length iff hasLength!S�_span>.    asyncBuf�_span is useful, for example, when performing expensive operations    on the elements of ranges tha4represen4data on a disk or network.
Example�_span>
import�_span std.conv, std.stdio;

void�_span main()
{        �] while processing previously fetched lines,
�_span    auto lines = File("foo.txt"�_span>).byLine();    auto duped = std.algorithm.map!"a.idup"�_span>(lines);
        �] into a matrix of doubles.
    double�_span>[][] matrix;
    auto�_span asyncReader = taskPool.asyncBuf(duped);

    foreach (line<span class="naked_sign">; </span><span class="naked_aural">(�l�)</span>asyncReader)    {        auto ls = line.split("\t"�_span>);
        matrix ~= to!(double�_span>[])(ls);
    }
}
�_pre>
�_div>

    Exception Handling:
�_div>

    An9exceptions thrown while iterating over source�_span are re-thrown on a    call to popFront�_span or, if thrown during construction, simply
    allowed to propagate to the caller.