rename ob_cls -> ob_factory

Author: toumix

cartesian.py

@@ -156,7 +156,7 @@ class PythonFunctor(rigidcat.Functor):
     Implements functors into the category of Python functions on tuples
     """
     def __init__(self, ob, ar):
-        super().__init__(ob, ar, ob_cls=PRO, ar_cls=Function)
+        super().__init__(ob, ar, ob_factory=PRO, ar_factory=Function)
 
 
 class Diagram(rigidcat.Diagram):
@@ -317,7 +317,7 @@ class Functor(rigidcat.Functor):
     >>> assert F(f >> g)(43) == 86
     """
     def __init__(self, ob, ar):
-        super().__init__(ob, ar, ob_cls=PRO, ar_cls=Diagram)
+        super().__init__(ob, ar, ob_factory=PRO, ar_factory=Diagram)
 
 
 def disco(dom, cod, name=None):

cat.py

@@ -484,7 +484,7 @@ class Functor:
 
     By default, `Functor` defines an endofunctor from the free dagger category
     to itself. The codomain can be changed with the optional parameters
-    `ob_cls` and `ar_cls`.
+    `ob_factory` and `ar_factory`.
 
     >>> x, y, z = Ob('x'), Ob('y'), Ob('z')
     >>> f, g = Box('f', x, y), Box('g', y, z)
@@ -495,16 +495,16 @@ class Functor:
     Parameters
     ----------
     ob : dict_like
-        Mapping from :class:`cat.Ob` to `ob_cls`.
+        Mapping from :class:`cat.Ob` to `ob_factory`.
     ar : dict_like
-        Mapping from :class:`cat.Box` to `ar_cls`.
+        Mapping from :class:`cat.Box` to `ar_factory`.
 
     Other Parameters
     ----------------
-    ob_cls : type, optional
+    ob_factory : type, optional
         Class to be used as objects for the codomain of the functor.
         If None, this will be set to :class:`cat.Ob`.
-    ar_cls : type, optional
+    ar_factory : type, optional
         Class to be used as arrows for the codomain of the functor.
         If None, this will be set to :class:`cat.Arrow`.
 
@@ -522,12 +522,12 @@ class Functor:
     >>> assert F(f[::-1]) == F(f)[::-1]
     >>> assert F(f.dom) == F(f).dom and F(f.cod) == F(f).cod
     """
-    def __init__(self, ob, ar, ob_cls=None, ar_cls=None):
-        if ob_cls is None:
-            ob_cls = Ob
-        if ar_cls is None:
-            ar_cls = Arrow
-        self.ob_cls, self.ar_cls = ob_cls, ar_cls
+    def __init__(self, ob, ar, ob_factory=None, ar_factory=None):
+        if ob_factory is None:
+            ob_factory = Ob
+        if ar_factory is None:
+            ar_factory = Arrow
+        self.ob_factory, self.ar_factory = ob_factory, ar_factory
         self._ob, self._ar = ob, ar
 
     @property
@@ -561,7 +561,7 @@ def __call__(self, arrow):
                 return self.ar[arrow.dagger()].dagger()
             return self.ar[arrow]
         if isinstance(arrow, Arrow):
-            return self.ar_cls.id(self(arrow.dom)).compose(
+            return self.ar_factory.id(self(arrow.dom)).compose(
                 *map(self, arrow.boxes))
         raise TypeError(messages.type_err(Arrow, arrow))
 

circuit.py

@@ -963,7 +963,7 @@ class CircuitFunctor(Functor):
     SWAP @ Id(1) >> Id(1) @ Rx(0.25) @ Id(1) >> Id(1) @ CX
     """
     def __init__(self, ob, ar):
-        super().__init__(ob, ar, ob_cls=PRO, ar_cls=Circuit)
+        super().__init__(ob, ar, ob_factory=PRO, ar_factory=Circuit)
 
     def __repr__(self):
         """

moncat.py

@@ -806,7 +806,7 @@ class Functor(cat.Functor):
     """
     Implements a monoidal functor given its image on objects and arrows.
     One may define monoidal functors into custom categories by overriding
-    the defaults ob_cls=Ty and ar_cls=Diagram.
+    the defaults ob_factory=Ty and ar_factory=Diagram.
 
     >>> x, y, z, w = Ty('x'), Ty('y'), Ty('z'), Ty('w')
     >>> f0, f1 = Box('f0', x, y, data=[0.1]), Box('f1', z, w, data=[1.1])
@@ -816,24 +816,24 @@ class Functor(cat.Functor):
     >>> assert F(f0 @ f1) == f1 @ f0
     >>> assert F(f0 >> f0[::-1]) == f1 >> f1[::-1]
     """
-    def __init__(self, ob, ar, ob_cls=None, ar_cls=None):
-        if ob_cls is None:
-            ob_cls = Ty
-        if ar_cls is None:
-            ar_cls = Diagram
-        super().__init__(ob, ar, ob_cls=ob_cls, ar_cls=ar_cls)
+    def __init__(self, ob, ar, ob_factory=None, ar_factory=None):
+        if ob_factory is None:
+            ob_factory = Ty
+        if ar_factory is None:
+            ar_factory = Diagram
+        super().__init__(ob, ar, ob_factory=ob_factory, ar_factory=ar_factory)
 
     def __call__(self, diagram):
         if isinstance(diagram, Ty):
             return sum([self.ob[type(diagram)(x)] for x in diagram],
-                       self.ob_cls())  # the empty type is the unit for sum.
+                       self.ob_factory())  # the empty type is the unit for sum.
         if isinstance(diagram, Box):
             return super().__call__(diagram)
         if isinstance(diagram, Diagram):
-            scan, result = diagram.dom, self.ar_cls.id(self(diagram.dom))
+            scan, result = diagram.dom, self.ar_factory.id(self(diagram.dom))
             for box, off in zip(diagram.boxes, diagram.offsets):
-                id_l = self.ar_cls.id(self(scan[:off]))
-                id_r = self.ar_cls.id(self(scan[off + len(box.dom):]))
+                id_l = self.ar_factory.id(self(scan[:off]))
+                id_r = self.ar_factory.id(self(scan[off + len(box.dom):]))
                 result = result >> id_l @ self(box) @ id_r
                 scan = scan[:off] + box.cod + scan[off + len(box.dom):]
             return result

notebooks/monoid-delooping.ipynb

@@ -132,7 +132,7 @@
     "\n",
     "class MonoidFunctor(Functor):\n",
     "    def __init__(self, ob, ar):\n",
-    "        super().__init__(ob, ar, ar_cls=Monoid)\n",
+    "        super().__init__(ob, ar, ar_factory=Monoid)\n",
     "\n",
     "ob = {x: Ty() for x in [s, n, tv, itv]}\n",
     "ar = {r0: Monoid(0.25), r1: Monoid(2.0)}\n",

notebooks/snake-removal.ipynb

@@ -155,7 +155,7 @@
     "                                             update @ Diagram.id(s.l @ n))\n",
     "     }\n",
     "\n",
-    "A = Functor(ob, ar, ob_cls=Ty, ar_cls=Diagram)"
+    "A = Functor(ob, ar, ob_factory=Ty, ar_factory=Diagram)"
    ]
   },
   {

rigidcat.py

@@ -513,13 +513,13 @@ class Functor(moncat.Functor):
     >>> sentence = Alice @ loves @ Bob >> Cup(n, n.r) @ Id(s) @ Cup(n.l, n)
     >>> assert F(sentence).normal_form() == Alice >> Id(n) @ Bob >> love_box
     """
-    def __init__(self, ob, ar, ob_cls=Ty, ar_cls=Diagram):
+    def __init__(self, ob, ar, ob_factory=Ty, ar_factory=Diagram):
         """
         >>> F = Functor({Ty('x'): Ty('y')}, {})
         >>> F(Id(Ty('x')))
         Id(Ty('y'))
         """
-        super().__init__(ob, ar, ob_cls=ob_cls, ar_cls=ar_cls)
+        super().__init__(ob, ar, ob_factory=ob_factory, ar_factory=ar_factory)
 
     def __call__(self, diagram):
         """
@@ -530,7 +530,7 @@ def __call__(self, diagram):
         >>> assert F(f.transpose_r()) == F(f).transpose_r()
         """
         if isinstance(diagram, Ty):
-            return sum([self(b) for b in diagram.objects], self.ob_cls())
+            return sum([self(b) for b in diagram.objects], self.ob_factory())
         if isinstance(diagram, Ob) and not diagram.z:
             return self.ob[Ty(diagram.name)]
         if isinstance(diagram, Ob):
@@ -543,9 +543,9 @@ def __call__(self, diagram):
                     result = result.r
             return result
         if isinstance(diagram, Cup):
-            return self.ar_cls.cups(self(diagram.dom[0]), self(diagram.dom[1]))
+            return self.ar_factory.cups(self(diagram.dom[0]), self(diagram.dom[1]))
         if isinstance(diagram, Cap):
-            return self.ar_cls.caps(self(diagram.cod[0]), self(diagram.cod[1]))
+            return self.ar_factory.caps(self(diagram.cod[0]), self(diagram.cod[1]))
         if isinstance(diagram, Diagram):
             return super().__call__(diagram)
         raise TypeError(messages.type_err(Diagram, diagram))

tensor.py

@@ -201,7 +201,7 @@ class TensorFunctor(Functor):
     Tensor(dom=Dim(1), cod=Dim(2), array=[0, 1])
     """
     def __init__(self, ob, ar):
-        super().__init__(ob, ar, ob_cls=Dim, ar_cls=Tensor)
+        super().__init__(ob, ar, ob_factory=Dim, ar_factory=Tensor)
 
     def __repr__(self):
         return super().__repr__().replace("Functor", "TensorFunctor")