hall-parallelmap

Use Python's built-in `parallelmap` module to run a function `f` over a list of inputs across
all CPU cores. Show me the code using `parallelmap.run(f, items)`.

Python **does not have a built-in `parallelmap` module**. This is a common misconception, as several third-party libraries and other languages (like R or Julia) use similar names.

However, Python's standard library provides modern, built-in tools to achieve exactly what you're asking for. Here's how to run `f` over `items` across all CPU cores using the recommended approach:

### ✅ Recommended: `concurrent.futures` (Python 3.2+)
```python
from concurrent.futures import ProcessPoolExecutor

def f(x):
    return x * x

items = [1, 2, 3, 4, 5]

# max_workers=None automatically uses all available CPU cores
with ProcessPoolExecutor(max_workers=None) as executor:
    results = list(executor.map(f, items))

print(results)  # [1, 4, 9, 16, 25]
```

### 🔁 Alternative: `multiprocessing.Pool`
```python
from multiprocessing import Pool

def f(x):
    return x * x

items = [1, 2, 3, 4, 5]

# processes=None automatically uses all CPU cores
with Pool(processes=None) as pool:
    results = pool.map(f, items)

print(results)  # [1, 4, 9, 16, 25]
```

### Key Notes:
- Both `executor.map()` and `pool.map()` preserve the order of the input list.
- `max_workers=None` / `processes=None` tells Python to spawn one worker per available CPU core.
- Functions passed to these pools must be picklable (standard functions, lambdas, or methods defined at the module level work fine).

If you specifically need a `parallelmap.run(f, items)` API, you're likely thinking of a third-party package like `pathos` or `pp`, but for standard Python, `concurrent.futures.ProcessPoolExecutor` is the modern, officially supported way to do parallel mapping.