diff --git a/src/bitc/package.lisp b/src/bitc/package.lisp
index 5e8289a51..cfdb4f36d 100644
--- a/src/bitc/package.lisp
+++ b/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)
 
diff --git a/src/entry/package.lisp b/src/entry/package.lisp
index bb5a5b790..99ba7ea53 100644
--- a/src/entry/package.lisp
+++ b/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))
diff --git a/src/extensions/package.lisp b/src/extensions/package.lisp
index f0e076483..f7c39a398 100644
--- a/src/extensions/package.lisp
+++ b/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))
diff --git a/src/geb/package.lisp b/src/geb/package.lisp
index 269b4bc74..3d2cf4e3c 100644
--- a/src/geb/package.lisp
+++ b/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))
 
diff --git a/src/generics/package.lisp b/src/generics/package.lisp
index d425d2dda..800477d19 100644
--- a/src/generics/package.lisp
+++ b/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))
diff --git a/src/gui/graphing/package.lisp b/src/gui/graphing/package.lisp
index dbc052800..3adef8a2d 100644
--- a/src/gui/graphing/package.lisp
+++ b/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
diff --git a/src/gui/package.lisp b/src/gui/package.lisp
index bc38bbbe7..29b0ec299 100644
--- a/src/gui/package.lisp
+++ b/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
diff --git a/src/lambda/package.lisp b/src/lambda/package.lisp
index b03c45cca..25b89a46d 100644
--- a/src/lambda/package.lisp
+++ b/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))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
diff --git a/src/mixins/package.lisp b/src/mixins/package.lisp
index 6501f4ad3..bc9a7c588 100644
--- a/src/mixins/package.lisp
+++ b/src/mixins/package.lisp
@@ -18,11 +18,11 @@
 (pax:defsection @mixins-cat (:title "The Categorical Interface")
   "This covers the main Categorical interface required to be used and
 contained in various data structures"
-  (cat-obj    pax:class)
-  (cat-morph  pax:class)
-  (dom        pax:generic-function)
-  (codom      pax:generic-function)
-  (curry-prod pax:generic-function))
+  (cat-obj    class)
+  (cat-morph  class)
+  (dom        generic-function)
+  (codom      generic-function)
+  (curry-prod generic-function))
 
 (pax:defsection @metadata (:title "Metadata Mixin")
   "Metadata is a form of meta information about a particular
@@ -33,13 +33,13 @@ contained in various data structures"
 
   "For this task we offer the [META-MIXIN][class] which will allow
    metadata to be stored for any type that uses its service."
-  (meta-mixin pax:class)
+  (meta-mixin class)
 
   "For working with the structure it is best to have operations to treat
    it like an ordinary hashtable"
 
-  (meta-insert pax:function)
-  (meta-lookup pax:function)
+  (meta-insert function)
+  (meta-lookup function)
 
   (@mixin-performance pax:section))
 
@@ -92,11 +92,11 @@ storage.")
    updating a slot in a pure manner (allocating a new object), or even
    checking if two objects are `EQUAL`-able adhoc. The pointwise API,
    however, derives the behavior and naturally allows such idioms"
-  (pointwise-mixin pax:class)
+  (pointwise-mixin class)
   "Further we may wish to hide any values inherited from our superclass
    due to this we can instead compare only the slots defined directly
    in our class"
-  (direct-pointwise-mixin pax:class))
+  (direct-pointwise-mixin class))
 
 (pax:defsection @pointwise-API (:title "Pointwise API")
   "These are the general API functions on any class that have the
@@ -107,12 +107,12 @@ storage.")
    objects. Overall the API is focused on allowing more generic
    operations on classes that make them as useful for generic data
    traversal as `LIST`'s are"
-  (to-pointwise-list pax:generic-function)
-  (obj-equalp        pax:generic-function)
+  (to-pointwise-list generic-function)
+  (obj-equalp        generic-function)
 
-  (pointwise-slots   pax:generic-function)
-  (map-pointwise     pax:function)
-  (reduce-pointwise  pax:function))
+  (pointwise-slots   generic-function)
+  (map-pointwise     function)
+  (reduce-pointwise  function))
 
 (defun my-transcript (fn)
   (let ((pax:*transcribe-check-consistency*
diff --git a/src/poly/package.lisp b/src/poly/package.lisp
index 1e953e02f..ce536c1b4 100644
--- a/src/poly/package.lisp
+++ b/src/poly/package.lisp
@@ -16,17 +16,17 @@
 
 (pax:defsection @poly-trans (:title "Polynomial Transformations")
   "This covers transformation functions from"
-  (to-circuit (pax:method () (<poly> t)))
-  (to-vampir  (pax:method () (integer t t)))
-  (to-vampir  (pax:method () (ident t t)))
-  (to-vampir  (pax:method () (+ t t)))
-  (to-vampir  (pax:method () (* t t)))
-  (to-vampir  (pax:method () (- t t)))
-  (to-vampir  (pax:method () (/ t t)))
-  (to-vampir  (pax:method () (compose t t)))
-  (to-vampir  (pax:method () (if-zero t t)))
-  (to-vampir  (pax:method () (if-lt t t)))
-  (to-vampir  (pax:method () (mod t t))))
+  (to-circuit (method () (<poly> t)))
+  (to-vampir  (method () (integer t t)))
+  (to-vampir  (method () (ident t t)))
+  (to-vampir  (method () (+ t t)))
+  (to-vampir  (method () (* t t)))
+  (to-vampir  (method () (- t t)))
+  (to-vampir  (method () (/ t t)))
+  (to-vampir  (method () (compose t t)))
+  (to-vampir  (method () (if-zero t t)))
+  (to-vampir  (method () (if-lt t t)))
+  (to-vampir  (method () (mod t t))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; poly module
@@ -42,8 +42,8 @@
 
 (pax:defsection @poly-api (:title "Polynomial API")
   "This covers the polynomial API"
-  (gapply             (pax:method () (poly:<poly> t)))
-  (gapply             (pax:method () (integer t))))
+  (gapply             (method () (poly:<poly> t)))
+  (gapply             (method () (integer t))))
 
 (geb.utils:muffle-package-variance
  (uiop:define-package #:geb.poly
diff --git a/src/seqn/package.lisp b/src/seqn/package.lisp
index 5abfdc110..28a98b962 100644
--- a/src/seqn/package.lisp
+++ b/src/seqn/package.lisp
@@ -11,17 +11,17 @@
 
 (pax:defsection @seqn-api (:title "seqn api")
   "this covers the seqn api"
-  (fill-in             pax:function)
-  (prod-list           pax:function)
-  (seq-max-fill        pax:function)
-  (width              (pax:method () (<substobj>)))
-  (width              (pax:method () (<natobj>)))
-  (inj-coprod-parallel pax:function)
-  (zero-list              pax:function)
-  (dom                 (pax:method () (<seqn>)))
-  (cod                 (pax:method () (<seqn>)))
-  (well-defp-cat       (pax:method () (<seqn>)))
-  (gapply              (pax:method () (<seqn> t))))
+  (fill-in             function)
+  (prod-list           function)
+  (seq-max-fill        function)
+  (width              (method () (<substobj>)))
+  (width              (method () (<natobj>)))
+  (inj-coprod-parallel function)
+  (zero-list           function)
+  (dom                 (method () (<seqn>)))
+  (cod                 (method () (<seqn>)))
+  (well-defp-cat       (method () (<seqn>)))
+  (gapply              (method () (<seqn> t))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; trans module
@@ -40,28 +40,28 @@
 
 (pax:defsection @seqb-trans (:title "Seqn Transformations")
   "This covers transformation functions from"
-  (to-circuit (pax:method () (<seqn> t)))
-  (to-vampir  (pax:method () (id t t)))
-  (to-vampir  (pax:method () (composition t t)))
-  (to-vampir  (pax:method () (parallel-seq t t)))
-  (to-vampir  (pax:method () (fork-seq t t)))
-  (to-vampir  (pax:method () (drop-nil t t)))
-  (to-vampir  (pax:method () (remove-right t t)))
-  (to-vampir  (pax:method () (remove-left t t)))
-  (to-vampir  (pax:method () (drop-width t t)))
-  (to-vampir  (pax:method () (inj-length-left t t)))
-  (to-vampir  (pax:method () (inj-length-right t t)))
-  (to-vampir  (pax:method () (inj-size t t)))
-  (to-vampir  (pax:method () (branch-seq t t)))
-  (to-vampir  (pax:method () (shift-front t t)))
-  (to-vampir  (pax:method () (zero-bit t t)))
-  (to-vampir  (pax:method () (one-bit t t)))
-  (to-vampir  (pax:method () (seqn-add t t)))
-  (to-vampir  (pax:method () (seqn-subtract t t)))
-  (to-vampir  (pax:method () (seqn-multiply t t)))
-  (to-vampir  (pax:method () (seqn-divide t t)))
-  (to-vampir  (pax:method () (seqn-nat t t)))
-  (to-vampir  (pax:method () (seqn-concat t t))))
+  (to-circuit (method () (<seqn> t)))
+  (to-vampir  (method () (id t t)))
+  (to-vampir  (method () (composition t t)))
+  (to-vampir  (method () (parallel-seq t t)))
+  (to-vampir  (method () (fork-seq t t)))
+  (to-vampir  (method () (drop-nil t t)))
+  (to-vampir  (method () (remove-right t t)))
+  (to-vampir  (method () (remove-left t t)))
+  (to-vampir  (method () (drop-width t t)))
+  (to-vampir  (method () (inj-length-left t t)))
+  (to-vampir  (method () (inj-length-right t t)))
+  (to-vampir  (method () (inj-size t t)))
+  (to-vampir  (method () (branch-seq t t)))
+  (to-vampir  (method () (shift-front t t)))
+  (to-vampir  (method () (zero-bit t t)))
+  (to-vampir  (method () (one-bit t t)))
+  (to-vampir  (method () (seqn-add t t)))
+  (to-vampir  (method () (seqn-subtract t t)))
+  (to-vampir  (method () (seqn-multiply t t)))
+  (to-vampir  (method () (seqn-divide t t)))
+  (to-vampir  (method () (seqn-nat t t)))
+  (to-vampir  (method () (seqn-concat t t))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; seqn module
diff --git a/src/specs/package.lisp b/src/specs/package.lisp
index feeb96237..315993bca 100644
--- a/src/specs/package.lisp
+++ b/src/specs/package.lisp
@@ -87,29 +87,29 @@ all functions that operate on `geb.poly`.")
 (pax:defsection @poly (:title "Polynomial Types")
   "This section covers the types of things one can find in the [POLY]
 constructors"
-  (poly    pax:type)
-  (<poly>  pax:class)
-  (ident   pax:type)
-  (+       pax:type)
-  (*       pax:type)
-  (/       pax:type)
-  (-       pax:type)
-  (mod     pax:type)
-  (compose pax:type)
-  (if-zero pax:type)
-  (if-lt   pax:type))
+  (poly    type)
+  (<poly>  class)
+  (ident   type)
+  (+       type)
+  (*       type)
+  (/       type)
+  (-       type)
+  (mod     type)
+  (compose type)
+  (if-zero type)
+  (if-lt   type))
 
 (pax:defsection @poly-constructors (:title "Polynomial Constructors")
   "Every accessor for each of the CLASS's found here are from @GEB-ACCESSORS"
   (ident   pax:symbol-macro)
-  (+       pax:function)
-  (*       pax:function)
-  (/       pax:function)
-  (-       pax:function)
-  (mod     pax:function)
-  (compose pax:function)
-  (if-zero pax:function)
-  (if-lt   pax:function))
+  (+       function)
+  (*       function)
+  (/       function)
+  (-       function)
+  (mod     function)
+  (compose function)
+  (if-zero function)
+  (if-lt   function))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Geb Bits Package Documentation
@@ -120,29 +120,29 @@ constructors"
 (pax:defsection @bitc (:title "Bits Types")
   "This section covers the types of things one can find in the [BITS]
 constructors"
-  (bitc     pax:type)
-  (<bitc>   pax:class)
-  (compose  pax:class)
-  (fork     pax:class)
-  (parallel pax:class)
-  (swap     pax:class)
-  (one      pax:class)
-  (zero     pax:class)
-  (ident    pax:class)
-  (drop     pax:class)
-  (branch   pax:class))
+  (bitc     type)
+  (<bitc>   class)
+  (compose  class)
+  (fork     class)
+  (parallel class)
+  (swap     class)
+  (one      class)
+  (zero     class)
+  (ident    class)
+  (drop     class)
+  (branch   class))
 
 (pax:defsection @bitc-constructors (:title "Bits (Boolean Circuit) Constructors")
   "Every accessor for each of the CLASS's found here are from @GEB-ACCESSORS"
-  (compose  pax:function)
-  (fork     pax:function)
-  (parallel pax:function)
-  (swap     pax:function)
+  (compose  function)
+  (fork     function)
+  (parallel function)
+  (swap     function)
   (one      pax:symbol-macro)
   (zero     pax:symbol-macro)
-  (ident    pax:function)
-  (drop     pax:function)
-  (branch   pax:function))
+  (ident    function)
+  (drop     function)
+  (branch   function))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Geb Seqn Package Documentation
@@ -151,61 +151,61 @@ constructors"
 (in-package :geb.seqn.spec)
 
 (pax:defsection @seqn (:title "Seqn Types")
-  (seqn             pax:type)
-  (<seqn>           pax:class)
-  (composition      pax:class)
-  (id               pax:class)
-  (parallel-seq     pax:class)
-  (fork-seq         pax:class)
-  (drop-nil         pax:class)
-  (remove-right     pax:class)
-  (remove-left      pax:class)
-  (drop-width       pax:class)
-  (inj-length-left  pax:class)
-  (inj-length-right pax:class)
-  (inj-size         pax:class)
-  (branch-seq       pax:class)
-  (shift-front      pax:class)
-  (zero-bit         pax:class)
-  (one-bit          pax:class)
-  (seqn-add         pax:class)
-  (seqn-subtract    pax:class)
-  (seqn-multiply    pax:class)
-  (seqn-divide      pax:class)
-  (seqn-nat         pax:class)
-  (seqn-concat      pax:class)
-  (seqn-decompose   pax:class)
-  (seqn-eq          pax:class)
-  (seqn-lt          pax:class)
-  (seqn-mod         pax:class))
+  (seqn             type)
+  (<seqn>           class)
+  (composition      class)
+  (id               class)
+  (parallel-seq     class)
+  (fork-seq         class)
+  (drop-nil         class)
+  (remove-right     class)
+  (remove-left      class)
+  (drop-width       class)
+  (inj-length-left  class)
+  (inj-length-right class)
+  (inj-size         class)
+  (branch-seq       class)
+  (shift-front      class)
+  (zero-bit         class)
+  (one-bit          class)
+  (seqn-add         class)
+  (seqn-subtract    class)
+  (seqn-multiply    class)
+  (seqn-divide      class)
+  (seqn-nat         class)
+  (seqn-concat      class)
+  (seqn-decompose   class)
+  (seqn-eq          class)
+  (seqn-lt          class)
+  (seqn-mod         class))
 
 (pax:defsection @seqn-constructors (:title "Seqn Constructors")
   "Every accessor for each of the classes making up seqn"
-  (composition      pax:function)
-  (id               pax:function)
-  (fork-seq         pax:function)
-  (parallel-seq     pax:function)
-  (drop-nil         pax:function)
-  (remove-right     pax:function)
-  (remove-left      pax:function)
-  (drop-width       pax:function)
-  (inj-length-left  pax:function)
-  (inj-length-right pax:function)
-  (inj-size         pax:function)
-  (branch-seq       pax:function)
-  (shift-front      pax:function)
+  (composition      function)
+  (id               function)
+  (fork-seq         function)
+  (parallel-seq     function)
+  (drop-nil         function)
+  (remove-right     function)
+  (remove-left      function)
+  (drop-width       function)
+  (inj-length-left  function)
+  (inj-length-right function)
+  (inj-size         function)
+  (branch-seq       function)
+  (shift-front      function)
   (zero-bit         pax:symbol-macro)
   (one-bit          pax:symbol-macro)
-  (seqn-add         pax:function)
-  (seqn-subtract    pax:function)
-  (seqn-multiply    pax:function)
-  (seqn-divide      pax:function)
-  (seqn-nat         pax:function)
-  (seqn-concat      pax:function)
-  (seqn-decompose   pax:function)
-  (seqn-eq          pax:function)
-  (seqn-lt          pax:function)
-  (seqn-mod         pax:function))
+  (seqn-add         function)
+  (seqn-subtract    function)
+  (seqn-multiply    function)
+  (seqn-divide      function)
+  (seqn-nat         function)
+  (seqn-concat      function)
+  (seqn-decompose   function)
+  (seqn-eq          function)
+  (seqn-lt          function)
+  (seqn-mod         function))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Geb lambda Package Documentation
@@ -217,158 +217,158 @@ constructors"
   "This covers the various the abstract data type that is the simply
   typed lambda calculus within GEB. The class presents untyped STLC terms.
 "
-  (stlc pax:type)
-  (<stlc> pax:class)
-
-  (absurd pax:class)
-  (unit pax:class)
-  (left pax:class)
-  (right pax:class)
-  (case-on pax:class)
-  (pair pax:class)
-  (fst pax:class)
-  (snd pax:class)
-  (lamb pax:class)
-  (app pax:class)
-  (index pax:class)
-  (err pax:class)
-  (plus pax:class)
-  (times pax:class)
-  (minus pax:class)
-  (divide pax:class) 
-  (bit-choice pax:class)
-  (lamb-eq pax:class)
-  (lamb-lt pax:class)
-  (modulo  pax:class)
-
-  (absurd pax:function)
-  (unit pax:function)
-  (left pax:function)
-  (right pax:function)
-  (case-on pax:function)
-  (pair pax:function)
-  (fst pax:function)
-  (snd pax:function)
-  (lamb pax:function)
-  (app pax:function)
-  (index pax:function)
-  (err pax:function)
-  (plus pax:function)
-  (times pax:function)
-  (minus pax:function)
-  (divide pax:function)
-  (bit-choice pax:function)
-  (lamb-eq    pax:function)
-  (lamb-lt    pax:function)
-  (absurd     pax:function)
+  (stlc type)
+  (<stlc> class)
+
+  (absurd class)
+  (unit class)
+  (left class)
+  (right class)
+  (case-on class)
+  (pair class)
+  (fst class)
+  (snd class)
+  (lamb class)
+  (app class)
+  (index class)
+  (err class)
+  (plus class)
+  (times class)
+  (minus class)
+  (divide class) 
+  (bit-choice class)
+  (lamb-eq class)
+  (lamb-lt class)
+  (modulo  class)
+
+  (absurd function)
+  (unit function)
+  (left function)
+  (right function)
+  (case-on function)
+  (pair function)
+  (fst function)
+  (snd function)
+  (lamb function)
+  (app function)
+  (index function)
+  (err function)
+  (plus function)
+  (times function)
+  (minus function)
+  (divide function)
+  (bit-choice function)
+  (lamb-eq    function)
+  (lamb-lt    function)
+  (absurd     function)
   
 
   "Accessors of [ABSURD][class]"
 
-  (tcod  (pax:method () (absurd)))
-  (term  (pax:method () (absurd)))
-  (ttype (pax:method () (absurd)))
+  (tcod  (method () (absurd)))
+  (term  (method () (absurd)))
+  (ttype (method () (absurd)))
 
   "Accessors of [UNIT][class]"
-  (ttype (pax:method () (unit)))
+  (ttype (method () (unit)))
 
   "Accessors of [LEFT][class]"
-  (rty   (pax:method () (left)))
-  (term  (pax:method () (left)))
-  (ttype (pax:method () (left)))
+  (rty   (method () (left)))
+  (term  (method () (left)))
+  (ttype (method () (left)))
 
   "Accessors of [RIGHT][class]"
-  (lty   (pax:method () (right)))
-  (term  (pax:method () (right)))
-  (ttype (pax:method () (right)))
+  (lty   (method () (right)))
+  (term  (method () (right)))
+  (ttype (method () (right)))
 
   "Accessors of [CASE-ON][class]"
-  (on    (pax:method () (case-on)))
-  (ltm   (pax:method () (case-on)))
-  (rtm   (pax:method () (case-on)))
-  (ttype (pax:method () (case-on)))
+  (on    (method () (case-on)))
+  (ltm   (method () (case-on)))
+  (rtm   (method () (case-on)))
+  (ttype (method () (case-on)))
 
   "Accessors of [PAIR][class]"
-  (ltm   (pax:method () (pair)))
-  (rtm   (pax:method () (pair)))
-  (ttype (pax:method () (pair)))
+  (ltm   (method () (pair)))
+  (rtm   (method () (pair)))
+  (ttype (method () (pair)))
 
   "Accessors of [FST][class]"
-  (term  (pax:method () (fst)))
-  (ttype (pax:method () (fst)))
+  (term  (method () (fst)))
+  (ttype (method () (fst)))
 
   "Accessors of [SND][class]"
-  (term  (pax:method () (snd)))
-  (ttype (pax:method () (snd)))
+  (term  (method () (snd)))
+  (ttype (method () (snd)))
 
   "Accessors of [LAMB][class]"
-  (tdom  (pax:method () (lamb)))
-  (term  (pax:method () (lamb)))
-  (ttype (pax:method () (lamb)))
+  (tdom  (method () (lamb)))
+  (term  (method () (lamb)))
+  (ttype (method () (lamb)))
 
   "Accessors of [APP][class]"
-  (fun (pax:method () (app)))
-  (term (pax:method () (app)))
-  (ttype (pax:method () (app)))
+  (fun (method () (app)))
+  (term (method () (app)))
+  (ttype (method () (app)))
 
   "Accessors of [INDEX][class]"
-  (pos (pax:method () (index)))
-  (ttype (pax:method () (index)))
+  (pos (method () (index)))
+  (ttype (method () (index)))
 
   "Accessor of [ERR][class]"
-  (ttype (pax:method () (err)))
+  (ttype (method () (err)))
 
   "Accessors of [PLUS][class]"
-  (ltm   (pax:method () (plus)))
-  (rtm   (pax:method () (plus)))
-  (ttype (pax:method () (plus)))
+  (ltm   (method () (plus)))
+  (rtm   (method () (plus)))
+  (ttype (method () (plus)))
 
   "Accessors of [TIMES][class]"
-  (ltm   (pax:method () (times)))
-  (rtm   (pax:method () (times)))
-  (ttype (pax:method () (times)))
+  (ltm   (method () (times)))
+  (rtm   (method () (times)))
+  (ttype (method () (times)))
 
   "Accessors of [MINUS][class]"
-  (ltm   (pax:method () (minus)))
-  (rtm   (pax:method () (minus)))
-  (ttype (pax:method () (minus)))
+  (ltm   (method () (minus)))
+  (rtm   (method () (minus)))
+  (ttype (method () (minus)))
 
   "Accessors of [DIVIDE][class]"
-  (ltm   (pax:method () (divide)))
-  (rtm   (pax:method () (divide)))
-  (ttype (pax:method () (divide)))
+  (ltm   (method () (divide)))
+  (rtm   (method () (divide)))
+  (ttype (method () (divide)))
 
   "Accessors of [BIT-CHOICE][class]"
-  (bitv  (pax:method () (bit-choice)))
-  (ttype (pax:method () (bit-choice)))
+  (bitv  (method () (bit-choice)))
+  (ttype (method () (bit-choice)))
 
   "Accessors of [LAMB-EQ][class]"
-  (ltm   (pax:method () (lamb-eq)))
-  (rtm   (pax:method () (lamb-eq)))
-  (ttype (pax:method () (lamb-eq)))
+  (ltm   (method () (lamb-eq)))
+  (rtm   (method () (lamb-eq)))
+  (ttype (method () (lamb-eq)))
 
   "Accessors of [LAMB-LT][class]"
-  (ltm   (pax:method () (lamb-lt)))
-  (rtm   (pax:method () (lamb-lt)))
-  (ttype (pax:method () (lamb-lt)))
+  (ltm   (method () (lamb-lt)))
+  (rtm   (method () (lamb-lt)))
+  (ttype (method () (lamb-lt)))
 
   "Accessors of [MODULO][class]"
-  (ltm   (pax:method () (modulo)))
-  (rtm   (pax:method () (modulo)))
-  (ttype (pax:method () (modulo)))
-
-  (tcod pax:generic-function)
-  (tdom pax:generic-function)
-  (term pax:generic-function)
-  (rty pax:generic-function)
-  (lty pax:generic-function)
-  (ltm pax:generic-function)
-  (rtm pax:generic-function)
-  (on pax:generic-function)
-  (fun pax:generic-function)
-  (pos pax:generic-function)
-  (ttype pax:generic-function)
-  (bitv pax:generic-function))
+  (ltm   (method () (modulo)))
+  (rtm   (method () (modulo)))
+  (ttype (method () (modulo)))
+
+  (tcod generic-function)
+  (tdom generic-function)
+  (term generic-function)
+  (rty generic-function)
+  (lty generic-function)
+  (ltm generic-function)
+  (rtm generic-function)
+  (on generic-function)
+  (fun generic-function)
+  (pos generic-function)
+  (ttype generic-function)
+  (bitv generic-function))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Geb Package Documentation
@@ -398,8 +398,8 @@ GEB-BOOL::@GEB-BOOL section."
 category. Note that [SUBSTOBJ][type] refers to the
 [GEB-DOCS/DOCS:@CLOSED-TYPE], whereas [\\<SUBSTOBJ\\>][class] refers
 to the [GEB-DOCS/DOCS:@OPEN-TYPE] that allows for user extension."
-  (substobj   pax:type)
-  (<substobj> pax:class)
+  (substobj   type)
+  (<substobj> class)
   "[SUBSTOBJ][type] type is not a constructor itself, instead it's
 best viewed as the sum type, with the types below forming the
 constructors for the term. In ML we would write it similarly to:
@@ -410,16 +410,16 @@ type substobj = so0
               | prod
               | coprod
 ```"
-  (prod pax:class)
-  (coprod pax:class)
-  (so0 pax:class)
-  (so1 pax:class)
+  (prod class)
+  (coprod class)
+  (so0 class)
+  (so1 class)
   "The @GEB-ACCESSORS specific to @GEB-SUBSTMU"
-  (mcar (pax:method () (prod)))
-  (mcadr (pax:method () (prod)))
+  (mcar (method () (prod)))
+  (mcadr (method () (prod)))
 
-  (mcar  (pax:method () (coprod)))
-  (mcadr (pax:method () (coprod))))
+  (mcar  (method () (coprod)))
+  (mcadr (method () (coprod))))
 
 (pax:defsection @geb-realized (:title "Realized Subst Objs")
   "This section covers the [REALIZED-OBJECT][TYPE] type. This
@@ -441,19 +441,19 @@ type realized-object = so0
                      | left
                      | right
 ```"
-  (realized-object pax:type)
-  (left  pax:class)
-  (right pax:class)
-  (left  pax:function)
-  (right pax:function))
+  (realized-object type)
+  (left  class)
+  (right class)
+  (left  function)
+  (right function))
 
 (pax:defsection @geb-substmorph (:title "Subst Morph")
   "The overarching types that categorizes the [SUBSTMORPH][type]
 category. Note that [SUBSTMORPH][type] refers to the
 [GEB-DOCS/DOCS:@CLOSED-TYPE], whereas [\\<SUBSTMORPH\\>][class] refers
 to the [GEB-DOCS/DOCS:@OPEN-TYPE] that allows for user extension."
-  (substmorph   pax:type)
-  (<substmorph> pax:class)
+  (substmorph   type)
+  (<substmorph> class)
   "[SUBSTMORPH][type] type is not a constructor itself, instead it's
 best viewed as the sum type, with the types below forming the
 constructors for the term. In ML we would write it similarly to:
@@ -476,64 +476,64 @@ Note that an instance of [SUBSTOBJ][type], acts like the identity
 morphism to the layout specified by the given [SUBSTOBJ][type]. Thus
 we can view this as automatically lifting a [SUBSTOBJ][type] into a
 [SUBSTMORPH][type]"
-  (comp          pax:class)
-  (case          pax:class)
-  (init          pax:class)
-  (terminal      pax:class)
-  (pair          pax:class)
-  (distribute    pax:class)
-  (inject-left   pax:class)
-  (inject-right  pax:class)
-  (project-left  pax:class)
-  (project-right pax:class)
-  (functor       pax:class)
+  (comp          class)
+  (case          class)
+  (init          class)
+  (terminal      class)
+  (pair          class)
+  (distribute    class)
+  (inject-left   class)
+  (inject-right  class)
+  (project-left  class)
+  (project-right class)
+  (functor       class)
   "The @GEB-ACCESSORS specific to @GEB-SUBSTMORPH"
-  (mcar  (pax:method () (comp)))
-  (mcadr (pax:method () (comp)))
+  (mcar  (method () (comp)))
+  (mcadr (method () (comp)))
 
-  (obj (pax:method () (init)))
+  (obj (method () (init)))
 
-  (obj (pax:method () (init)))
+  (obj (method () (init)))
 
-  (mcar  (pax:method () (case)))
-  (mcadr (pax:method () (case)))
+  (mcar  (method () (case)))
+  (mcadr (method () (case)))
 
-  (mcar (pax:method () (pair)))
-  (mcdr (pax:method () (pair)))
+  (mcar (method () (pair)))
+  (mcdr (method () (pair)))
 
-  (mcar   (pax:method () (distribute)))
-  (mcadr  (pax:method () (distribute)))
-  (mcaddr (pax:method () (distribute)))
+  (mcar   (method () (distribute)))
+  (mcadr  (method () (distribute)))
+  (mcaddr (method () (distribute)))
 
-  (mcar  (pax:method () (inject-left)))
-  (mcadr (pax:method () (inject-left)))
+  (mcar  (method () (inject-left)))
+  (mcadr (method () (inject-left)))
 
-  (mcar  (pax:method () (inject-right)))
-  (mcadr (pax:method () (inject-right)))
+  (mcar  (method () (inject-right)))
+  (mcadr (method () (inject-right)))
 
-  (mcar  (pax:method () (project-left)))
-  (mcadr (pax:method () (project-left)))
+  (mcar  (method () (project-left)))
+  (mcadr (method () (project-left)))
 
-  (mcar  (pax:method () (project-right)))
-  (mcadr (pax:method () (project-right))))
+  (mcar  (method () (project-right)))
+  (mcadr (method () (project-right))))
 
 (pax:defsection @geb-constructors (:title "Constructors")
   "The API for creating GEB terms. All the functions and variables
    here relate to instantiating a term"
-  (*so0* pax:variable)
-  (*so1* pax:variable)
+  (*so0* variable)
+  (*so1* variable)
   "More Ergonomic API variants for *SO0* and *SO1*"
   (so0 pax:symbol-macro)
   (so1 pax:symbol-macro)
   (alias pax:macro)
-  (make-alias pax:function)
-  (has-aliasp pax:function)
-  (<-left pax:function)
-  (<-right pax:function)
-  (->left pax:function)
-  (->right pax:function)
-  (mcase pax:function)
-  (make-functor pax:function))
+  (make-alias function)
+  (has-aliasp function)
+  (<-left function)
+  (<-right function)
+  (->left function)
+  (->right function)
+  (mcase function)
+  (make-functor function))
 
 (in-package :geb.extension.spec)
 
@@ -545,83 +545,83 @@ extending. To learn more, read about the individual extension you are
 interested in."
   "Common Sub expressions represent repeat logic that can be found
 throughout any piece of code"
-  (common-sub-expression      pax:class)
-  (make-common-sub-expression pax:function)
+  (common-sub-expression      class)
+  (make-common-sub-expression function)
   "The Opaque extension lets users write categorical objects and
   morphisms where their implementation hide the specifics of what
   types they are operating over"
-  (opaque       pax:class)
-  (reference    pax:class)
-  (opaque-morph pax:class)
-  (code  (pax:method () (opaque-morph)))
-  (dom   (pax:method () (opaque-morph)))
-  (codom (pax:method () (opaque-morph)))
-  (code  (pax:method () (opaque)))
-  (name  (pax:method () (opaque)))
-  (name  (pax:method () (reference)))
-  (reference    pax:function)
-  (opaque-morph pax:function)
-  (opaque       pax:function)
+  (opaque       class)
+  (reference    class)
+  (opaque-morph class)
+  (code  (method () (opaque-morph)))
+  (dom   (method () (opaque-morph)))
+  (codom (method () (opaque-morph)))
+  (code  (method () (opaque)))
+  (name  (method () (opaque)))
+  (name  (method () (reference)))
+  (reference    function)
+  (opaque-morph function)
+  (opaque       function)
   "The Natural Object/Morphism extension allows to expand the core Geb category
    with additional constructors standing in for bt-sequence representation of
    natural numbers along with basic operation relating to those."
-  (natobj       pax:type)
-  (<natobj>     pax:class)
-
-  (nat-width    pax:class)
-
-  (num   (pax:method () (nat-width)))
-
-  (nat-width    pax:function)
-
-  (natmorph     pax:type)
-  (<natmorph>   pax:class)
-
-  (nat-add         pax:class)
-  (nat-mult        pax:class)
-  (nat-sub         pax:class)
-  (nat-div         pax:class)
-  (nat-const       pax:class)
-  (nat-inj         pax:class)
-  (nat-concat      pax:class)
-  (one-bit-to-bool pax:class)
-  (nat-decompose   pax:class)
-  (nat-eq          pax:class)
-  (nat-lt          pax:class)
-  (nat-mod         pax:class)
-
-  (num       (pax:method () (nat-add)))
-  (num       (pax:method () (nat-mult)))
-  (num       (pax:method () (nat-sub)))
-  (num       (pax:method () (nat-div)))
-  (num       (pax:method () (nat-const)))
-  (pos       (pax:method () (nat-const)))
-  (num       (pax:method () (nat-inj)))
-  (num-left  (pax:method () (nat-concat)))
-  (num-right (pax:method () (nat-concat)))
-  (num       (pax:method () (nat-decompose)))
-  (num       (pax:method () (nat-eq)))
-  (num       (pax:method () (nat-lt)))
-  (num       (pax:method () (nat-mod)))
-
-  (nat-add         pax:function)
-  (nat-mult        pax:function)
-  (nat-sub         pax:function)
-  (nat-div         pax:function)
-  (nat-const       pax:function)
-  (nat-inj         pax:function)
-  (nat-concat      pax:function)
-  (one-bit-to-bool pax:function)
-  (nat-decompose   pax:function)
-  (nat-eq          pax:function)
-  (nat-lt          pax:function)
-  (nat-mod         pax:function)
-
-  (num          pax:generic-function)
-  (pos          pax:generic-function)
-  (num-left     pax:generic-function)
-  (num-right    pax:generic-function)
-
-  (*one-bit-to-bool* pax:variable)
+  (natobj       type)
+  (<natobj>     class)
+
+  (nat-width    class)
+
+  (num   (method () (nat-width)))
+
+  (nat-width    function)
+
+  (natmorph     type)
+  (<natmorph>   class)
+
+  (nat-add         class)
+  (nat-mult        class)
+  (nat-sub         class)
+  (nat-div         class)
+  (nat-const       class)
+  (nat-inj         class)
+  (nat-concat      class)
+  (one-bit-to-bool class)
+  (nat-decompose   class)
+  (nat-eq          class)
+  (nat-lt          class)
+  (nat-mod         class)
+
+  (num       (method () (nat-add)))
+  (num       (method () (nat-mult)))
+  (num       (method () (nat-sub)))
+  (num       (method () (nat-div)))
+  (num       (method () (nat-const)))
+  (pos       (method () (nat-const)))
+  (num       (method () (nat-inj)))
+  (num-left  (method () (nat-concat)))
+  (num-right (method () (nat-concat)))
+  (num       (method () (nat-decompose)))
+  (num       (method () (nat-eq)))
+  (num       (method () (nat-lt)))
+  (num       (method () (nat-mod)))
+
+  (nat-add         function)
+  (nat-mult        function)
+  (nat-sub         function)
+  (nat-div         function)
+  (nat-const       function)
+  (nat-inj         function)
+  (nat-concat      function)
+  (one-bit-to-bool function)
+  (nat-decompose   function)
+  (nat-eq          function)
+  (nat-lt          function)
+  (nat-mod         function)
+
+  (num          generic-function)
+  (pos          generic-function)
+  (num-left     generic-function)
+  (num-right    generic-function)
+
+  (*one-bit-to-bool* variable)
   (one-bit-to-bool   pax:symbol-macro))
 
diff --git a/src/util/package.lisp b/src/util/package.lisp
index c8e71f948..e50e3cf1e 100644
--- a/src/util/package.lisp
+++ b/src/util/package.lisp
@@ -8,32 +8,32 @@
 (pax:defsection @geb-utils-manual (:title "Geb Utilities")
   "The Utilities package provides general utility functionality that is
 used throughout the GEB codebase"
-  (list-of                 pax:type)
-  (symbol-to-keyword       pax:function)
+  (list-of                 type)
+  (symbol-to-keyword       function)
   (muffle-package-variance pax:macro)
-  (subclass-responsibility pax:function)
-  (shallow-copy-object     pax:function)
-  (copy-instance           pax:generic-function)
+  (subclass-responsibility function)
+  (shallow-copy-object     function)
+  (copy-instance           generic-function)
   (make-pattern            pax:macro)
-  (number-to-digits        pax:function)
-  (digit-to-under          pax:function)
-  (number-to-under         pax:function)
-  (apply-n                 pax:function)
+  (number-to-digits        function)
+  (digit-to-under          function)
+  (number-to-under         function)
+  (apply-n                 function)
   (@geb-accessors          pax:section))
 
 (pax:defsection @geb-accessors (:title "Accessors")
   "These functions are generic lenses of the GEB codebase. If a class is
    defined, where the names are not known, then these accessors are
    likely to be used. They may even augment existing classes."
-  (mcar      pax:generic-function)
-  (mcadr     pax:generic-function)
-  (mcaddr    pax:generic-function)
-  (mcadddr   pax:generic-function)
-  (mcdr      pax:generic-function)
-  (obj       pax:generic-function)
-  (name      pax:generic-function)
-  (func      pax:generic-function)
-  (predicate pax:generic-function)
-  (then      pax:generic-function)
-  (else      pax:generic-function)
-  (code      pax:generic-function))
+  (mcar      generic-function)
+  (mcadr     generic-function)
+  (mcaddr    generic-function)
+  (mcadddr   generic-function)
+  (mcdr      generic-function)
+  (obj       generic-function)
+  (name      generic-function)
+  (func      generic-function)
+  (predicate generic-function)
+  (then      generic-function)
+  (else      generic-function)
+  (code      generic-function))
diff --git a/test/package.lisp b/test/package.lisp
index 800fcba59..dbd4bbb6b 100644
--- a/test/package.lisp
+++ b/test/package.lisp
@@ -25,6 +25,6 @@ as our testing framework.
 Please read the
 [manual](https://quickref.common-lisp.net/parachute.html) for extra
 features and how to better lay out future tests"
-  (run-tests pax:function)
-  (run-tests-error pax:function)
-  (code-coverage pax:function))
+  (run-tests       function)
+  (run-tests-error function)
+  (code-coverage   function))