Fix mgl-pax Symbol Errors

src/bitc/package.lisp

@@ -15,16 +15,16 @@
 
 (pax:defsection @bitc-trans (:title "Bits (Boolean Circuit) Transformations")
   "This covers transformation functions from"
-  (to-circuit (pax:method () (<bitc> t)))
-  (to-vampir  (pax:method () (compose t t)))
-  (to-vampir  (pax:method () (fork t t)))
-  (to-vampir  (pax:method () (parallel t t)))
-  (to-vampir  (pax:method () (swap t t)))
-  (to-vampir  (pax:method () (one t t)))
-  (to-vampir  (pax:method () (zero t t)))
-  (to-vampir  (pax:method () (ident t t)))
-  (to-vampir  (pax:method () (drop t t)))
-  (to-vampir  (pax:method () (branch t t))))
+  (to-circuit (method () (<bitc> t)))
+  (to-vampir  (method () (compose t t)))
+  (to-vampir  (method () (fork t t)))
+  (to-vampir  (method () (parallel t t)))
+  (to-vampir  (method () (swap t t)))
+  (to-vampir  (method () (one t t)))
+  (to-vampir  (method () (zero t t)))
+  (to-vampir  (method () (ident t t)))
+  (to-vampir  (method () (drop t t)))
+  (to-vampir  (method () (branch t t))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; bitc module
@@ -48,10 +48,10 @@
 
 (pax:defsection @bitc-api (:title "Bits (Boolean Circuit) API")
   "This covers the Bits (Boolean Circuit) API"
-  (gapply (pax:method () (<bitc> bit-vector)))
-  (gapply (pax:method () (<bitc> list)))
-  (dom    (pax:method () (<bitc>)))
-  (codom  (pax:method () (<bitc>))))
+  (gapply (method () (<bitc> bit-vector)))
+  (gapply (method () (<bitc> list)))
+  (dom    (method () (<bitc>)))
+  (codom  (method () (<bitc>))))
 
 (in-package :geb.bitc)
 

src/entry/package.lisp

@@ -83,4 +83,4 @@ expects a symbol.
 the -l flag means that we are not expecting a geb term, but rather a
 lambda frontend term, this is to simply notify us to compile it as a
 lambda term rather than a geb term. In time this will go away"
-  (compile-down pax:function))
+  (compile-down function))

src/extensions/package.lisp

@@ -12,6 +12,6 @@
 
 (pax:defsection @sub-expressions (:title "Sub Expression API")
   "Here we cover functions regarding common sub-expressions"
-  (keep-unique            pax:function)
-  (compute-common-usages  pax:function)
-  (common-sub-expressions pax:function))
+  (keep-unique            function)
+  (compute-common-usages  function)
+  (common-sub-expressions function))

src/geb/package.lisp

@@ -15,28 +15,28 @@
 
 (pax:defsection @geb-utility (:title "Utility")
   "Various utility functions ontop of @GEB-CATEGORIES"
-  (pair-to-list      pax:function)
-  (same-type-to-list pax:function)
-  (cleave            pax:function)
-  (const             pax:function)
-  (commutes          pax:function)
-  (commutes-left     pax:function)
-  (!->               pax:function)
-  (so-eval           (pax:method () (<natobj> t)))
-  (so-eval           (pax:method () (<substobj> t)))
-  (so-hom-obj        (pax:method () (<natobj> t)))
-  (so-hom-obj        (pax:method () (<substobj> t)))
-  (so-card-alg       pax:generic-function)
-  (so-card-alg       (pax:method () (<substobj>)))
-  (curry             pax:function)
-  (coprod-mor        pax:function)
-  (prod-mor          pax:function)
-  (uncurry           pax:function)
-  (text-name         pax:generic-function)
+  (pair-to-list      function)
+  (same-type-to-list function)
+  (cleave            function)
+  (const             function)
+  (commutes          function)
+  (commutes-left     function)
+  (!->               function)
+  (so-eval           (method () (<natobj> t)))
+  (so-eval           (method () (<substobj> t)))
+  (so-hom-obj        (method () (<natobj> t)))
+  (so-hom-obj        (method () (<substobj> t)))
+  (so-card-alg       generic-function)
+  (so-card-alg       (method () (<substobj>)))
+  (curry             function)
+  (coprod-mor        function)
+  (prod-mor          function)
+  (uncurry           function)
+  (text-name         generic-function)
 
   "These utilities are ontop of [CAT-OBJ]"
-  (maybe             (pax:method () (<substobj>)))
-  (maybe             (pax:method () (<natobj>))))
+  (maybe             (method () (<substobj>)))
+  (maybe             (method () (<natobj>))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Standard Library throughout the codebase
@@ -69,29 +69,29 @@
 (pax:defsection @geb-translation (:title "Translation Functions")
   "These cover various conversions from @GEB-SUBSTMORPH and @GEB-SUBSTMU
 into other categorical data structures."
-  (to-poly    (pax:method () (<substobj>)))
-  (to-poly    (pax:method () (<substmorph>)))
-  (to-circuit (pax:method () (<substmorph> t)))
-  (to-bitc    (pax:method () (<substmorph>)))
-  (to-seqn    (pax:method () (<substobj>)))
-  (to-seqn    (pax:method () (geb.extension.spec:<natobj>)))
-  (to-seqn    (pax:method () (comp)))
-  (to-seqn    (pax:method () (init)))
-  (to-seqn    (pax:method () (terminal)))
-  (to-seqn    (pax:method () (inject-left)))
-  (to-seqn    (pax:method () (inject-right)))
-  (to-seqn    (pax:method () (case)))
-  (to-seqn    (pax:method () (project-left)))
-  (to-seqn    (pax:method () (project-right)))
-  (to-seqn    (pax:method () (pair)))
-  (to-seqn    (pax:method () (distribute)))
-  (to-seqn    (pax:method () (geb.extension.spec:nat-div)))
-  (to-seqn    (pax:method () (geb.extension.spec:nat-const)))
-  (to-seqn    (pax:method () (geb.extension.spec:nat-inj)))
-  (to-seqn    (pax:method () (geb.extension.spec:one-bit-to-bool)))
-  (to-seqn    (pax:method () (geb.extension.spec:nat-decompose)))
-  (to-seqn    (pax:method () (geb.extension.spec:nat-eq)))
-  (to-seqn    (pax:method () (geb.extension.spec:nat-lt))))
+  (to-poly    (method () (<substobj>)))
+  (to-poly    (method () (<substmorph>)))
+  (to-circuit (method () (<substmorph> t)))
+  (to-bitc    (method () (<substmorph>)))
+  (to-seqn    (method () (<substobj>)))
+  (to-seqn    (method () (geb.extension.spec:<natobj>)))
+  (to-seqn    (method () (comp)))
+  (to-seqn    (method () (init)))
+  (to-seqn    (method () (terminal)))
+  (to-seqn    (method () (inject-left)))
+  (to-seqn    (method () (inject-right)))
+  (to-seqn    (method () (case)))
+  (to-seqn    (method () (project-left)))
+  (to-seqn    (method () (project-right)))
+  (to-seqn    (method () (pair)))
+  (to-seqn    (method () (distribute)))
+  (to-seqn    (method () (geb.extension.spec:nat-div)))
+  (to-seqn    (method () (geb.extension.spec:nat-const)))
+  (to-seqn    (method () (geb.extension.spec:nat-inj)))
+  (to-seqn    (method () (geb.extension.spec:one-bit-to-bool)))
+  (to-seqn    (method () (geb.extension.spec:nat-decompose)))
+  (to-seqn    (method () (geb.extension.spec:nat-eq)))
+  (to-seqn    (method () (geb.extension.spec:nat-lt))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; bool module
@@ -169,15 +169,15 @@ We likewise define it with coproducts, with the recursive type being opaque
 ```
 
 The functions given work on this."
-  (*nil*       pax:variable)
-  (*cons-type* pax:variable)
-  (*list*      pax:variable)
-  (*car*       pax:variable)
-  (*cons*      pax:variable)
-  (*cdr*       pax:variable)
+  (*nil*       variable)
+  (*cons-type* variable)
+  (*list*      variable)
+  (*car*       variable)
+  (*cons*      variable)
+  (*cdr*       variable)
   (cons->list  pax:symbol-macro)
   (nil->list   pax:symbol-macro)
-  (*canonical-cons-type* pax:variable))
+  (*canonical-cons-type* variable))
 
 (geb.utils:muffle-package-variance
  (uiop:define-package #:geb-decision
@@ -240,14 +240,14 @@ We also define out API functions to operate on this"
 
 (pax:defsection @geb-api (:title "API")
   "Various forms and structures built on-top of @GEB-CATEGORIES"
-  (gapply                     (pax:method () (<substmorph> t)))
-  (gapply                     (pax:method () (opaque-morph t)))
-  (gapply                     (pax:method () (opaque t)))
-  (well-defp-cat              (pax:method () (<substmorph>)))
-  (well-defp-cat              (pax:method () (<natmorph>)))
-  (well-defp-cat              (pax:method () (<natobj>)))
-  (geb-bool:@geb-bool        pax:section)
-  (geb-list:@geb-list        pax:section)
+  (gapply                     (method () (<substmorph> t)))
+  (gapply                     (method () (opaque-morph t)))
+  (gapply                     (method () (opaque t)))
+  (well-defp-cat              (method () (<substmorph>)))
+  (well-defp-cat              (method () (<natmorph>)))
+  (well-defp-cat              (method () (<natobj>)))
+  (geb-bool:@geb-bool         pax:section)
+  (geb-list:@geb-list         pax:section)
   (geb.trans:@geb-translation pax:section)
   (@geb-utility               pax:section))
 

src/generics/package.lisp

@@ -13,15 +13,15 @@ You can view their documentation in their respective API sections.
 
 The main documentation for the functionality is given here, with
 examples often given in the specific methods"
-  (gapply         pax:generic-function)
-  (well-defp-cat  pax:generic-function)
-  (maybe          pax:generic-function)
-  (so-hom-obj     pax:generic-function)
-  (so-eval        pax:generic-function)
-  (width          pax:generic-function)
-  (to-circuit     pax:generic-function)
-  (to-bitc        pax:generic-function)
-  (to-seqn        pax:generic-function)
-  (to-poly        pax:generic-function)
-  (to-cat         pax:generic-function)
-  (to-vampir      pax:generic-function))
+  (gapply         generic-function)
+  (well-defp-cat  generic-function)
+  (maybe          generic-function)
+  (so-hom-obj     generic-function)
+  (so-eval        generic-function)
+  (width          generic-function)
+  (to-circuit     generic-function)
+  (to-bitc        generic-function)
+  (to-seqn        generic-function)
+  (to-poly        generic-function)
+  (to-cat         generic-function)
+  (to-vampir      generic-function))

src/gui/graphing/package.lisp

@@ -10,21 +10,21 @@ object into a format for a graphing backend."
   ;; please write more, me.  Put this is the API section, not
   ;; here... we should talk about the backends here!!!!!!!
   "The core types that facilittate the functionality"
-  (note pax:type)
-  (node pax:class)
-  (node-note pax:class)
-  (squash-note pax:class)
-  (make-note pax:function)
-  (make-squash pax:function)
-  (graphize pax:generic-function)
-  (value pax:generic-function)
-  (cons-note pax:function)
-  (apply-note pax:function)
-  (representation pax:generic-function)
-  (children       pax:generic-function)
-  (determine-text-and-object-from-node pax:function)
-  (noterize-children                   pax:function)
-  (notorize-children-with-index-schema pax:function))
+  (note type)
+  (node class)
+  (node-note class)
+  (squash-note class)
+  (make-note function)
+  (make-squash function)
+  (graphize generic-function)
+  (value generic-function)
+  (cons-note function)
+  (apply-note function)
+  (representation generic-function)
+  (children       generic-function)
+  (determine-text-and-object-from-node function)
+  (noterize-children                   function)
+  (notorize-children-with-index-schema function))
 
 
 (geb.utils:muffle-package-variance
@@ -39,7 +39,7 @@ object into a format for a graphing backend."
 (pax:defsection @pass-manual (:title "The GEB Graphizer Passes")
   "This changes how the graph is visualized, simplifying the graph in
 ways that are intuitive to the user"
-  (passes pax:function))
+  (passes function))
 
 
 (geb.utils:muffle-package-variance

src/gui/package.lisp

@@ -21,14 +21,14 @@ the [GEB:SUBSTMORPH][type] changes any incoming term.
 
 if the visualizer gets a GEB:@GEB-SUBSTMU, then it shows the data
 layout of the term, showing what kind of data "
-  (visualize       pax:function)
-  (kill-running    pax:function)
+  (visualize       function)
+  (kill-running    function)
   (@visaulizer-aid pax:section))
 
 (pax:defsection @geb-exporter (:title "Export Visualizer")
   "This works like the normal visualizer except it exports it to a
   file to be used by other projects or perhaps in papers"
-  (svg pax:function))
+  (svg function))
 
 (pax:defsection @visaulizer-aid (:title "Aiding the Visualizer")
   "One can aid the visualization process a bit, this can be done by

src/lambda/package.lisp

@@ -16,21 +16,21 @@
 (pax:defsection @lambda-api (:title "Main functionality")
   "This covers the main API for the STLC module"
 
-  (ann-term1          pax:generic-function)
-  (index-check        pax:function)
-  (fun-to-hom         pax:function)
-  (ann-term2          pax:function)
-  (annotated-term     pax:function)
-  (type-of-term-w-fun pax:function)
-  (type-of-term       pax:function)
-  (well-defp          pax:generic-function)
-  (fun-type           pax:class)
-  (fun-type           pax:function)
-  (errorp             pax:function)
-  (reducer            pax:function)
-
-  (mcar              (pax:method () (fun-type)))
-  (mcadr             (pax:method () (fun-type))))
+  (ann-term1          generic-function)
+  (index-check        function)
+  (fun-to-hom         function)
+  (ann-term2          function)
+  (annotated-term     function)
+  (type-of-term-w-fun function)
+  (type-of-term       function)
+  (well-defp          generic-function)
+  (fun-type           class)
+  (fun-type           function)
+  (errorp             function)
+  (reducer            function)
+
+  (mcar              (method () (fun-type)))
+  (mcadr             (method () (fun-type))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; trans module
@@ -48,8 +48,8 @@
 
 (pax:defsection @utility (:title "Utility Functionality")
   "These are utility functions relating to translating lambda terms to other types"
-  (stlc-ctx-to-mu  pax:function)
-  (so-hom  pax:function))
+  (stlc-ctx-to-mu  function)
+  (so-hom  function))
 
 (pax:defsection @stlc-conversion (:title "Transition Functions")
   "These functions deal with transforming the data structure to other
@@ -61,11 +61,11 @@ transition functions except [TO-CAT] do not take a context.
 Thus if the [\\<STLC\\>] term contains free variables, then call
 [TO-CAT] and give it the desired context before calling
 any other transition functions"
-  (to-cat     (pax:method () (t <stlc>)))
-  (to-poly    (pax:method () (<stlc>)))
-  (to-bitc    (pax:method () (<stlc>)))
-  (to-seqn    (pax:method () (<stlc>)))
-  (to-circuit (pax:method () (<stlc> t)))
+  (to-cat     (method () (t <stlc>)))
+  (to-poly    (method () (<stlc>)))
+  (to-bitc    (method () (<stlc>)))
+  (to-seqn    (method () (<stlc>)))
+  (to-circuit (method () (<stlc> t)))
   (@utility   pax:section))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;