Is it possible to use functools.singledispatch with composite/nested/container types in Python?

Question

Edit 2022-08-30: perhaps with the introduction of variadic generics (PEP-646) in Python 3.11, dispatch with composite types may become possible.

I wonder whether the following can be achieved, and if so, without requiring much extra code:

from __future__ import annotations
from functools import singledispatch

@singledispatch
def somefunc(value):
    print(f"Type {type(value).__qualname__!r} "
          f"is not registered for dispatch.")

@somefunc.register
def _(value: list[int]):
    print(f"Dispatched type list[int]!")

@somefunc.register
def _(value: list[str]):
    print(f"Dispatched type list[str]!")

somefunc('123')
somefunc([123])
somefunc(list('123'))

And get output:

Type 'str' is not registered for dispatch.
Dispatched type list[int]!
Dispatched type list[str]!

Running this snippet with python 3.9.6, however, instead results in an error at line 742 of functools.py:

TypeError: issubclass() argument 2 cannot be 
a parameterized generic

As singledispatch does work for user defined classes, one way to make this work is to typecheck the elements in the passed list, wrap the passed list into a class representing e.g. list[str] and have the dispatched function call itself again with the new instance as argument:

from __future__ import annotations
from functools import singledispatch


class ListOfStrs(list):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class ListOfInts(list):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


@singledispatch
def somefunc(value):
    print(f"Type {type(value).__qualname__!r} "
          f"is not registered for dispatch.")


@somefunc.register
def _(value: list):
    if value and all(isinstance(subval, int) 
                     for subval in value):
        somefunc(ListOfInts(value))

    elif value and all(isinstance(subval, str) 
                       for subval in value):
        somefunc(ListOfStrs(value))

    else:
        print(
            f"Dispatched a list whose elements ",
            f"are not all of a registered type."
            )


@somefunc.register
def _(value: ListOfStrs):
    print(f"Dispatched type 'list[str]'!")


@somefunc.register
def _(value: ListOfInts):
    print(f"Dispatched type 'list[int]'!")


somefunc('123')
somefunc([1, 2, 3])
somefunc(list('123'))
somefunc([{1}, {2}, {3}])

Which, as expected, results in:

Type 'str' is not registered for dispatch.
Dispatched type 'list[int]'!
Dispatched type 'list[str]'!
Dispatched a list whose elements are 
 not all of a registered type.

However, besides increasing extensibility, one of the reasons to use singledispatch in the first place is to circumvent verbose typechecks, which some consider an anti-pattern. And of course for this solution specifically, you'd need to define the wrapper classes which litter the code (there may be a better way of achieving this that I currently don't see, but the first point still stands).

One could reason one typecheck for 'list' is avoided here, but that reduces complexity just by just one if/else clause.

So I wouldn't actually use the last case.

Does anyone know how to get this behaviour as elegantly as can be done with non-composite types?

I suppose this could be done elegantly using pattern matching in 3.10. So maybe I should wait for its launch and maturation if this is currently not feasible?