Mapear itens em paralelo, resultados pela ordem de entrada snippet

// Promise.all settles by INPUT INDEX, not completion time:
const results = await Promise.all(
  items.map((item, i) => fetchItem(item, i)),
);
// results[0] is items[0]'s result even if it resolved last.

// collect-everything instead of fail-fast:
const settled = await Promise.allSettled(items.map(fetchItem));
const ok = settled.flatMap(s => (s.status === 'fulfilled' ? [s.value] : []));

async function parallelMap<T, R>(
  items: readonly T[],
  fn: (item: T, index: number) => Promise<R>,
): Promise<R[]> {
  return Promise.all(items.map((item, i) => fn(item, i)));
}

import "golang.org/x/sync/errgroup"

func parallelMap[T, R any](items []T, fn func(T) (R, error)) ([]R, error) {
	results := make([]R, len(items)) // pre-sized: no append, no shared writer
	var g errgroup.Group
	g.SetLimit(8) // bounded — 10k items must not mean 10k goroutines
	for i, item := range items {
		g.Go(func() error {
			res, err := fn(item)
			if err != nil {
				return err
			}
			results[i] = res // safe: each goroutine writes its OWN slot
			return nil
		})
	}
	if err := g.Wait(); err != nil {
		return nil, err
	}
	return results, nil
}

use rayon::prelude::*;

let results: Vec<u16> = urls
    .par_iter()                    // work-stealing parallel iterator
    .map(|url| fetch_status(url))
    .collect();                    // Vec in INPUT order

// async twin: futures::future::join_all(futs).await

// trap: array_map is SEQUENTIAL — PHP core has no parallel map.
// CPU-bound fallback (CLI + unix only): fork workers over slices,
// serialize each slice back, merge BY INDEX (keys preserved):
function parallel_map(array $items, callable $fn, int $workers = 4): array {
    $chunks = array_chunk($items, (int) ceil(count($items) / $workers), true);
    $pairs  = [];
    foreach ($chunks as $chunk) {
        [$parent, $child] = stream_socket_pair(STREAM_PF_UNIX, STREAM_SOCK_STREAM, 0);
        $pairs[] = [$parent, $child];
        if (pcntl_fork() === 0) {              // worker process
            fclose($parent);
            fwrite($child, serialize(array_map($fn, $chunk)));
            exit(0);
        }
        fclose($child);
    }
    $results = [];
    foreach ($pairs as [$parent]) {
        $results += unserialize(stream_get_contents($parent)); // union keeps keys
        fclose($parent);
    }
    pcntl_waitpid(0, $status); // reap workers
    ksort($results);
    return $results;
}

from concurrent.futures import ThreadPoolExecutor

with ThreadPoolExecutor(max_workers=8) as pool:
    lazy = pool.map(fetch, items)   # LAZY and ORDERED
    results = list(lazy)            # list() forces the work
# asyncio twin: await asyncio.gather(*[fetch(i) for i in items])

using System;
using System.Linq;
using System.Threading.Tasks;

static async Task<R[]> ParallelMapAsync<T, R>(
    IEnumerable<T> items, Func<T, Task<R>> fn) =>
    await Task.WhenAll(items.Select(fn)); // R[] in SOURCE order

// collect-everything: wrap each, then partition —
static async Task<(R[] ok, Exception[] failed)> Partition<T, R>(
    IEnumerable<T> items, Func<T, Task<R>> fn)
{
    var wrapped = await Task.WhenAll(items.Select(async item =>
    {
        try { return (value: await fn(item), error: null as Exception); }
        catch (Exception e) { return (default!, e); }
    }));
    return (wrapped.Where(w => w.error is null).Select(w => w.value!).ToArray(),
            wrapped.Where(w => w.error is not null).Select(w => w.error!).ToArray());
}

import java.util.concurrent.*;
import java.util.ArrayList;
import java.util.List;

static <R> List<R> parallelMap(List<Callable<R>> tasks) throws InterruptedException {
    try (ExecutorService pool = Executors.newFixedThreadPool(8)) {
        List<Future<R>> futures = pool.invokeAll(tasks); // blocks until ALL finish
        List<R> results = new ArrayList<>(futures.size());
        for (Future<R> f : futures) {   // futures are in SUBMISSION order
            results.add(f.get());       // wraps the task's exception
        }
        return results;
    }
}

func parallelMap<T, R: Sendable>(
    _ items: [T], _ transform: @Sendable (T) async throws -> R
) async throws -> [R] {
    var results = [R?](repeating: nil, count: items.count)
    try await withThrowingTaskGroup(of: (Int, R).self) { group in
        for (i, item) in items.enumerated() {
            group.addTask { (i, try await transform(item)) } // CARRY the index
        }
        for try await (i, value) in group {  // yields in COMPLETION order
            results[i] = value               // index restores input order
        }
    }
    return results.map { $0! }
}

suspend fun <T, R> parallelMap(
    items: List<T>,
    fn: suspend (T) -> R,
): List<R> = coroutineScope {
    items.map { item ->
        async { fn(item) }   // launched in input order
    }.awaitAll()             // results in LAUNCH order, not completion
}

def parallel_map(items, &fn)
  results = Array.new(items.size)          # pre-sized slots
  threads = items.each_with_index.map do |item, i|
    Thread.new { results[i] = fn.call(item) } # index-write: own slot
  end
  threads.each(&:join)
  results
end

const std = @import("std");

// fixed pool: workers pull indexes from one atomic counter
fn parallelMap(
    gpa: std.mem.Allocator,
    comptime workers: usize,
    items: []const u32,
    out: []u32,
) !void {
    var next = std.atomic.Value(usize).init(0);

    const Worker = struct {
        fn run(items: []const u32, out: []u32, next: *std.atomic.Value(usize)) void {
            while (true) {
                const i = next.fetchAdd(1, .monotonic); // claim one index
                if (i >= items.len) return;
                out[i] = transform(items[i]);           // write OWN slot
            }
        }
    };

    const threads = try gpa.alloc(std.Thread, workers - 1);
    defer gpa.free(threads);
    for (threads) |*t|
        t.* = try std.Thread.spawn(.{}, Worker.run, .{ items, out, &next });

    Worker.run(items, out, &next); // the main thread is worker N
    for (threads) |t| t.join();    // every worker has drained the counter
}