Replace '_starfilter' with 'jaraco.functools.splat'.

distutils/_functools.py

@@ -1,3 +1,4 @@
+import collections.abc
 import functools
 
 
@@ -18,3 +19,55 @@ def wrapper(param, *args, **kwargs):
             return func(param, *args, **kwargs)
 
     return wrapper
+
+
+# from jaraco.functools 4.0
+@functools.singledispatch
+def _splat_inner(args, func):
+    """Splat args to func."""
+    return func(*args)
+
+
+@_splat_inner.register
+def _(args: collections.abc.Mapping, func):
+    """Splat kargs to func as kwargs."""
+    return func(**args)
+
+
+def splat(func):
+    """
+    Wrap func to expect its parameters to be passed positionally in a tuple.
+
+    Has a similar effect to that of ``itertools.starmap`` over
+    simple ``map``.
+
+    >>> import itertools, operator
+    >>> pairs = [(-1, 1), (0, 2)]
+    >>> _ = tuple(itertools.starmap(print, pairs))
+    -1 1
+    0 2
+    >>> _ = tuple(map(splat(print), pairs))
+    -1 1
+    0 2
+
+    The approach generalizes to other iterators that don't have a "star"
+    equivalent, such as a "starfilter".
+
+    >>> list(filter(splat(operator.add), pairs))
+    [(0, 2)]
+
+    Splat also accepts a mapping argument.
+
+    >>> def is_nice(msg, code):
+    ...     return "smile" in msg or code == 0
+    >>> msgs = [
+    ...     dict(msg='smile!', code=20),
+    ...     dict(msg='error :(', code=1),
+    ...     dict(msg='unknown', code=0),
+    ... ]
+    >>> for msg in filter(splat(is_nice), msgs):
+    ...     print(msg)
+    {'msg': 'smile!', 'code': 20}
+    {'msg': 'unknown', 'code': 0}
+    """
+    return functools.wraps(func)(functools.partial(_splat_inner, func=func))

distutils/dep_util.py

@@ -4,6 +4,7 @@
 
 from .errors import DistutilsFileError
 from .py39compat import zip_strict
+from ._functools import splat
 
 
 def _newer(source, target):
@@ -27,13 +28,6 @@ def newer(source, target):
     return _newer(source, target)
 
 
-def _starfilter(pred, iterables):
-    """
-    Like itertools.starmap but for filter.
-    """
-    return filter(lambda x: pred(*x), iterables)
-
-
 def newer_pairwise(sources, targets):
     """
     Filter filenames where sources are newer than targets.
@@ -43,7 +37,7 @@ def newer_pairwise(sources, targets):
     targets) where source is newer than target, according to the semantics
     of 'newer()'.
     """
-    newer_pairs = _starfilter(newer, zip_strict(sources, targets))
+    newer_pairs = filter(splat(newer), zip_strict(sources, targets))
     return tuple(map(list, zip(*newer_pairs)))