core.common: move listify to core.utils.itertools, use better typing annotations for it

also some minor refactoring of my.rss

my/core/common.py

@@ -65,29 +65,6 @@ def import_dir(path: PathIsh, extra: str='') -> types.ModuleType:
     return import_from(p.parent, p.name + extra)
 
 
-# https://stackoverflow.com/a/12377059/706389
-def listify(fn=None, wrapper=list):
-    """
-    Wraps a function's return value in wrapper (e.g. list)
-    Useful when an algorithm can be expressed more cleanly as a generator
-    """
-    def listify_return(fn):
-        @functools.wraps(fn)
-        def listify_helper(*args, **kw):
-            return wrapper(fn(*args, **kw))
-        return listify_helper
-    if fn is None:
-        return listify_return
-    return listify_return(fn)
-
-
-# todo use in bluemaestro
-# def dictify(fn=None, key=None, value=None):
-#     def md(it):
-#         return make_dict(it, key=key, value=value)
-#     return listify(fn=fn, wrapper=md)
-
-
 from .logging import setup_logger, LazyLogger
 
 
@@ -628,12 +605,18 @@ if not TYPE_CHECKING:
             res[kk] = lst
         return res
 
-    @deprecated('use my.core.utils.make_dict instead')
+    @deprecated('use my.core.utils.itertools.make_dict instead')
     def make_dict(*args, **kwargs):
         from .utils import itertools as UI
 
         return UI.make_dict(*args, **kwargs)
 
+    @deprecated('use my.core.utils.itertools.listify instead')
+    def listify(*args, **kwargs):
+        from .utils import itertools as UI
+
+        return UI.listify(*args, **kwargs)
+
     # todo wrap these in deprecated decorator as well?
     from .cachew import mcachew  # noqa: F401
 

my/core/utils/itertools.py

@@ -4,8 +4,11 @@ Various helpers/transforms of iterators
 Ideally this should be as small as possible and we should rely on stdlib itertools or more_itertools
 """
 
-from typing import Callable, Dict, Iterable, TypeVar, cast
+from typing import Callable, Dict, Iterable, Iterator, TypeVar, List, cast, TYPE_CHECKING
 
+from ..compat import ParamSpec
+
+from decorator import decorator
 
 T = TypeVar('T')
 K = TypeVar('K')
@@ -75,3 +78,39 @@ def test_make_dict() -> None:
     # check type inference
     d2: Dict[str, int] = make_dict(it, key=lambda i: str(i))
     d3: Dict[str, bool] = make_dict(it, key=lambda i: str(i), value=lambda i: i % 2 == 0)
+
+
+LFP = ParamSpec('LFP')
+LV = TypeVar('LV')
+
+
+@decorator
+def _listify(func: Callable[LFP, Iterable[LV]], *args: LFP.args, **kwargs: LFP.kwargs) -> List[LV]:
+    """
+    Wraps a function's return value in wrapper (e.g. list)
+    Useful when an algorithm can be expressed more cleanly as a generator
+    """
+    return list(func(*args, **kwargs))
+
+
+# ugh. decorator library has stub types, but they are way too generic?
+# tried implementing my own stub, but failed -- not sure if it's possible at all?
+# so seems easiest to just use specialize instantiations of decorator instead
+if TYPE_CHECKING:
+
+    def listify(func: Callable[LFP, Iterable[LV]]) -> Callable[LFP, List[LV]]: ...
+
+else:
+    listify = _listify
+
+
+def test_listify() -> None:
+    @listify
+    def it() -> Iterator[int]:
+        yield 1
+        yield 2
+
+    res = it()
+    from typing_extensions import assert_type  # TODO move to compat?
+    assert_type(res, List[int])
+    assert res == [1, 2]