sorted topological more logical + handle generics in typings.

Author: kessido

fastcore/dispatch.py

@@ -22,12 +22,18 @@ def anno_ret(func):
     if not ann: return None
     return ann.get('return')
 
+# Cell
+def _lenient_issubclass(cls, types):
+    "If possible return whether `cls` is a subclass of `types`, otherwise return False."
+    try: return isinstance(cls, types) or issubclass(cls, types)
+    except: return False
+
 # Cell
 def sorted_topologically(iterable, *, cmp=operator.lt, reverse=False):
     "Return a new list containing all items from the iterable sorted topologically"
     l,res = L(list(iterable)),[]
     for _ in range(len(l)):
-        t = l.reduce(lambda x,y: y if cmp(x,y) else x)
+        t = l.reduce(lambda x,y: y if cmp(y,x) else x)
         res.append(t), l.remove(t)
     return res[::-1] if reverse else res
 
@@ -55,7 +61,7 @@ class _TypeDict:
     def __init__(self): self.d,self.cache = {},{}
 
     def _reset(self):
-        self.d = {k:self.d[k] for k in sorted_topologically(self.d, cmp=issubclass, reverse=True)}
+        self.d = {k:self.d[k] for k in sorted_topologically(self.d, cmp=_lenient_issubclass)}
         self.cache = {}
 
     def add(self, t, f):

nbs/03_dispatch.ipynb

@@ -194,6 +194,43 @@
     "test_eq(anno_ret(None), None) # instead of passing in a func, pass in None"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#export\n",
+    "def _lenient_issubclass(cls, types):\n",
+    "    \"If possible return whether `cls` is a subclass of `types`, otherwise return False.\"\n",
+    "    try: return isinstance(cls, types) or issubclass(cls, types)\n",
+    "    except: return False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# depict the need for _lenient_issubclass:\n",
+    "t = lambda: issubclass(typing.Collection, object)\n",
+    "test_fail(t, contains='issubclass() arg 1 must be a class')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert not _lenient_issubclass(typing.Collection, list)\n",
+    "assert _lenient_issubclass(list, typing.Collection)\n",
+    "assert _lenient_issubclass(typing.Collection, object)\n",
+    "assert _lenient_issubclass(typing.List, typing.Collection)\n",
+    "assert not _lenient_issubclass(typing.Collection, typing.List)"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -205,20 +242,30 @@
     "    \"Return a new list containing all items from the iterable sorted topologically\"\n",
     "    l,res = L(list(iterable)),[]\n",
     "    for _ in range(len(l)):\n",
-    "        t = l.reduce(lambda x,y: y if cmp(x,y) else x)\n",
+    "        t = l.reduce(lambda x,y: y if cmp(y,x) else x)\n",
     "        res.append(t), l.remove(t)\n",
     "    return res[::-1] if reverse else res"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "td = [3, 1, 2, 5]\n",
+    "test_eq(sorted_topologically(td), [1, 2, 3, 5])\n",
+    "test_eq(sorted_topologically(td, reverse=True), [5, 3, 2, 1])"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "td = {int:1, numbers.Number:2, numbers.Integral:3}\n",
-    "test_eq(sorted_topologically(td, cmp=issubclass), [numbers.Number, numbers.Integral, int])\n",
-    "test_eq(sorted_topologically(td, cmp=issubclass, reverse=True), [int, numbers.Integral, numbers.Number])"
+    "test_eq(sorted_topologically(td, cmp=_lenient_issubclass), [int, numbers.Integral, numbers.Number])"
    ]
   },
   {
@@ -227,8 +274,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "td = sorted_topologically([numbers.Integral, tuple, list, int, dict], cmp=issubclass)\n",
-    "assert td.index(numbers.Integral) < td.index(int)"
+    "td = [numbers.Integral, tuple, list, int, dict]\n",
+    "td = sorted_topologically(td, cmp=_lenient_issubclass)\n",
+    "assert td.index(int) < td.index(numbers.Integral)"
    ]
   },
   {
@@ -358,7 +406,7 @@
     "    def __init__(self): self.d,self.cache = {},{}\n",
     "\n",
     "    def _reset(self):\n",
-    "        self.d = {k:self.d[k] for k in sorted_topologically(self.d, cmp=issubclass, reverse=True)}\n",
+    "        self.d = {k:self.d[k] for k in sorted_topologically(self.d, cmp=_lenient_issubclass)}\n",
     "        self.cache = {}\n",
     "\n",
     "    def add(self, t, f):\n",
@@ -605,12 +653,12 @@
     {
      "data": {
       "text/plain": [
-       "(list,object) -> f_bll\n",
-       "(typing.Collection,object) -> f_col\n",
        "(bool,object) -> f_bll\n",
        "(int,object) -> f_ni2\n",
        "(Integral,object) -> f_nin\n",
        "(Number,object) -> f_num\n",
+       "(list,object) -> f_bll\n",
+       "(typing.Collection,object) -> f_col\n",
        "(object,object) -> NoneType"
       ]
      },