Coverage report: /home/runner/work/geb/geb/src/specs/package.lisp

KindCoveredAll%
expression035 0.0
branch00nil
Key
Not instrumented
Conditionalized out
Executed
Not executed
 
Both branches taken
One branch taken
Neither branch taken
1
 (in-package :geb.utils)
2
 
3
 (muffle-package-variance
4
  (defpackage #:geb.specs
5
    (:use #:cl)))
6
 
7
 (muffle-package-variance
8
  (defpackage #:geb.poly.spec
9
    (:shadow :+ :* :/ :- :mod)
10
    (:use #:geb.utils #:cl)
11
    (:export #:@poly #:@poly-constructors)))
12
 
13
 (muffle-package-variance
14
  (defpackage #:geb.bitc.spec
15
    (:export :dom :codom)
16
    (:shadow :drop :fork)
17
    (:use #:geb.utils #:cl #:geb.mixins)
18
    (:export #:@bitc #:@bitc-constructors)))
19
 
20
 (muffle-package-variance
21
  (defpackage #:geb.seqn.spec
22
    (:use #:geb.utils #:cl #:geb.mixins)
23
    (:export #:@seqn #:@seqn-constructors)))
24
 
25
 ;; please document this later.
26
 (muffle-package-variance
27
  (uiop:define-package #:geb.lambda.spec
28
    (:documentation "Basic spec for creating lambda terms")
29
    (:mix #:trivia #:serapeum #:common-lisp #:geb.mixins)
30
    (:export #:@lambda-specs)))
31
 
32
 (pax:define-package #:geb.spec
33
   (:documentation "Gödel, Escher, Bach categorical model")
34
   (:use #:common-lisp #:serapeum #:geb.mixins #:geb.utils)
35
   (:shadow :left :right :prod :case)
36
   (:export :prod :case :mcar :mcadr :mcaddr :mcdr :name :func :obj
37
    :same-type-to-list :pair-to-list
38
    #:@geb-categories #:@geb-substmu #:@geb-substmorph #:@geb-constructors #:@geb-realized))
39
 
40
 (muffle-package-variance
41
  (uiop:define-package #:geb.extension.spec
42
    (:documentation "Extensions of the various categories")
43
    (:mix #:trivia #:serapeum #:common-lisp #:geb.mixins #:geb.utils)
44
    (:export #:@geb-extensions)))
45
 
46
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
47
 ;; Geb Package Documentation
48
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
49
 
50
 (in-package :geb.specs)
51
 
52
 (pax:defsection @geb-specs (:title "Spec Files, Main Files and Project Layout")
53
   "The codebase is split between many files. Each folder can be seen as
54
 a different idea within geb itself! Thus the `poly` has packages
55
 revolving around polynomials, the `geb` folder has packages regarding
56
 the main types of geb GEB.SPEC:@GEB-SUBSTMU and
57
 GEB.SPEC:@GEB-SUBSTMORPH, etc etc.
58
 
59
 The general layout quirk of the codebase is that packages like
60
 `geb.package.spec` defines the specification for the base types for
61
 any category we wish to model, and these reside in the `specs` folder
62
 not in the folder that talks about the packages of those types. This
63
 is due to loading order issues, we thus load the `specs` packages
64
 before each of their surrounding packages, so that each package can
65
 built off the last. Further, packages like `geb.package.main` define
66
 out most of the functionality of the package to be used by other
67
 packages in `geb.package`, then all of these are reexported out in the
68
 `geb.package` package
69
 
70
 Further to make working with each package of an idea is easy, we have
71
 the main package of the folder (typically named the same as the folder
72
 name) reexport most important components so if one wants to work with
73
 the fully fledged versions of the package they can simply without
74
 having to import too many packages at once.
75
 
76
 For example, the `geb.poly.spec` defines out the types and data
77
 structures of the GEB.POLY.SPEC:@POLY, this is then rexported
78
 in `geb.poly`, giving the module `geb.poly` a convenient interface for
79
 all functions that operate on `geb.poly`.")
80
 
81
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
82
 ;; Geb Poly Package Documentation
83
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
84
 
85
 (in-package :geb.poly.spec)
86
 
87
 (pax:defsection @poly (:title "Polynomial Types")
88
   "This section covers the types of things one can find in the [POLY]
89
 constructors"
90
   (poly    pax:type)
91
   (<poly>  pax:class)
92
   (ident   pax:type)
93
   (+       pax:type)
94
   (*       pax:type)
95
   (/       pax:type)
96
   (-       pax:type)
97
   (mod     pax:type)
98
   (compose pax:type)
99
   (if-zero pax:type)
100
   (if-lt   pax:type))
101
 
102
 (pax:defsection @poly-constructors (:title "Polynomial Constructors")
103
   "Every accessor for each of the CLASS's found here are from @GEB-ACCESSORS"
104
   (ident   pax:symbol-macro)
105
   (+       pax:function)
106
   (*       pax:function)
107
   (/       pax:function)
108
   (-       pax:function)
109
   (mod     pax:function)
110
   (compose pax:function)
111
   (if-zero pax:function)
112
   (if-lt   pax:function))
113
 
114
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
115
 ;; Geb Bits Package Documentation
116
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
117
 
118
 (in-package :geb.bitc.spec)
119
 
120
 (pax:defsection @bitc (:title "Bits Types")
121
   "This section covers the types of things one can find in the [BITS]
122
 constructors"
123
   (bitc     pax:type)
124
   (<bitc>   pax:class)
125
   (compose  pax:class)
126
   (fork     pax:class)
127
   (parallel pax:class)
128
   (swap     pax:class)
129
   (one      pax:class)
130
   (zero     pax:class)
131
   (ident    pax:class)
132
   (drop     pax:class)
133
   (branch   pax:class))
134
 
135
 (pax:defsection @bitc-constructors (:title "Bits (Boolean Circuit) Constructors")
136
   "Every accessor for each of the CLASS's found here are from @GEB-ACCESSORS"
137
   (compose  pax:function)
138
   (fork     pax:function)
139
   (parallel pax:function)
140
   (swap     pax:function)
141
   (one      pax:symbol-macro)
142
   (zero     pax:symbol-macro)
143
   (ident    pax:function)
144
   (drop     pax:function)
145
   (branch   pax:function))
146
 
147
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
148
 ;; Geb Seqn Package Documentation
149
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
150
 
151
 (in-package :geb.seqn.spec)
152
 
153
 (pax:defsection @seqn (:title "Seqn Types")
154
   (seqn             pax:type)
155
   (<seqn>           pax:class)
156
   (composition      pax:class)
157
   (id               pax:class)
158
   (parallel-seq     pax:class)
159
   (fork-seq         pax:class)
160
   (drop-nil         pax:class)
161
   (remove-right     pax:class)
162
   (remove-left      pax:class)
163
   (drop-width       pax:class)
164
   (inj-length-left  pax:class)
165
   (inj-length-right pax:class)
166
   (inj-size         pax:class)
167
   (branch-seq       pax:class)
168
   (shift-front      pax:class)
169
   (zero-bit         pax:class)
170
   (one-bit          pax:class)
171
   (seqn-add         pax:class)
172
   (seqn-subtract    pax:class)
173
   (seqn-multiply    pax:class)
174
   (seqn-divide      pax:class)
175
   (seqn-nat         pax:class)
176
   (seqn-concat      pax:class)
177
   (seqn-decompose   pax:class)
178
   (seqn-eq          pax:class)
179
   (seqn-lt          pax:class)
180
   (seqn-mod         pax:class))
181
 
182
 (pax:defsection @seqn-constructors (:title "Seqn Constructors")
183
   "Every accessor for each of the classes making up seqn"
184
   (composition      pax:function)
185
   (id               pax:function)
186
   (fork-seq         pax:function)
187
   (parallel-seq     pax:function)
188
   (drop-nil         pax:function)
189
   (remove-right     pax:function)
190
   (remove-left      pax:function)
191
   (drop-width       pax:function)
192
   (inj-length-left  pax:function)
193
   (inj-length-right pax:function)
194
   (inj-size         pax:function)
195
   (branch-seq       pax:function)
196
   (shift-front      pax:function)
197
   (zero-bit         pax:symbol-macro)
198
   (one-bit          pax:symbol-macro)
199
   (seqn-add         pax:function)
200
   (seqn-subtract    pax:function)
201
   (seqn-multiply    pax:function)
202
   (seqn-divide      pax:function)
203
   (seqn-nat         pax:function)
204
   (seqn-concat      pax:function)
205
   (seqn-decompose   pax:function)
206
   (seqn-eq          pax:function)
207
   (seqn-lt          pax:function)
208
   (seqn-mod         pax:function))
209
 
210
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
211
 ;; Geb lambda Package Documentation
212
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
213
 
214
 (in-package :geb.lambda.spec)
215
 
216
 (pax:defsection @lambda-specs (:title "Lambda Specification")
217
   "This covers the various the abstract data type that is the simply
218
   typed lambda calculus within GEB. The class presents untyped STLC terms.
219
 "
220
   (stlc pax:type)
221
   (<stlc> pax:class)
222
 
223
   (absurd pax:class)
224
   (unit pax:class)
225
   (left pax:class)
226
   (right pax:class)
227
   (case-on pax:class)
228
   (pair pax:class)
229
   (fst pax:class)
230
   (snd pax:class)
231
   (lamb pax:class)
232
   (app pax:class)
233
   (index pax:class)
234
   (err pax:class)
235
   (plus pax:class)
236
   (times pax:class)
237
   (minus pax:class)
238
   (divide pax:class) 
239
   (bit-choice pax:class)
240
   (lamb-eq pax:class)
241
   (lamb-lt pax:class)
242
   (modulo  pax:class)
243
 
244
   (absurd pax:function)
245
   (unit pax:function)
246
   (left pax:function)
247
   (right pax:function)
248
   (case-on pax:function)
249
   (pair pax:function)
250
   (fst pax:function)
251
   (snd pax:function)
252
   (lamb pax:function)
253
   (app pax:function)
254
   (index pax:function)
255
   (err pax:function)
256
   (plus pax:function)
257
   (times pax:function)
258
   (minus pax:function)
259
   (divide pax:function)
260
   (bit-choice pax:function)
261
   (lamb-eq    pax:function)
262
   (lamb-lt    pax:function)
263
   (absurd     pax:function)
264
   
265
 
266
   "Accessors of [ABSURD][class]"
267
 
268
   (tcod  (pax:method () (absurd)))
269
   (term  (pax:method () (absurd)))
270
   (ttype (pax:method () (absurd)))
271
 
272
   "Accessors of [UNIT][class]"
273
   (ttype (pax:method () (unit)))
274
 
275
   "Accessors of [LEFT][class]"
276
   (rty   (pax:method () (left)))
277
   (term  (pax:method () (left)))
278
   (ttype (pax:method () (left)))
279
 
280
   "Accessors of [RIGHT][class]"
281
   (lty   (pax:method () (right)))
282
   (term  (pax:method () (right)))
283
   (ttype (pax:method () (right)))
284
 
285
   "Accessors of [CASE-ON][class]"
286
   (on    (pax:method () (case-on)))
287
   (ltm   (pax:method () (case-on)))
288
   (rtm   (pax:method () (case-on)))
289
   (ttype (pax:method () (case-on)))
290
 
291
   "Accessors of [PAIR][class]"
292
   (ltm   (pax:method () (pair)))
293
   (rtm   (pax:method () (pair)))
294
   (ttype (pax:method () (pair)))
295
 
296
   "Accessors of [FST][class]"
297
   (term  (pax:method () (fst)))
298
   (ttype (pax:method () (fst)))
299
 
300
   "Accessors of [SND][class]"
301
   (term  (pax:method () (snd)))
302
   (ttype (pax:method () (snd)))
303
 
304
   "Accessors of [LAMB][class]"
305
   (tdom  (pax:method () (lamb)))
306
   (term  (pax:method () (lamb)))
307
   (ttype (pax:method () (lamb)))
308
 
309
   "Accessors of [APP][class]"
310
   (fun (pax:method () (app)))
311
   (term (pax:method () (app)))
312
   (ttype (pax:method () (app)))
313
 
314
   "Accessors of [INDEX][class]"
315
   (pos (pax:method () (index)))
316
   (ttype (pax:method () (index)))
317
 
318
   "Accessor of [ERR][class]"
319
   (ttype (pax:method () (err)))
320
 
321
   "Accessors of [PLUS][class]"
322
   (ltm   (pax:method () (plus)))
323
   (rtm   (pax:method () (plus)))
324
   (ttype (pax:method () (plus)))
325
 
326
   "Accessors of [TIMES][class]"
327
   (ltm   (pax:method () (times)))
328
   (rtm   (pax:method () (times)))
329
   (ttype (pax:method () (times)))
330
 
331
   "Accessors of [MINUS][class]"
332
   (ltm   (pax:method () (minus)))
333
   (rtm   (pax:method () (minus)))
334
   (ttype (pax:method () (minus)))
335
 
336
   "Accessors of [DIVIDE][class]"
337
   (ltm   (pax:method () (divide)))
338
   (rtm   (pax:method () (divide)))
339
   (ttype (pax:method () (divide)))
340
 
341
   "Accessors of [BIT-CHOICE][class]"
342
   (bitv  (pax:method () (bit-choice)))
343
   (ttype (pax:method () (bit-choice)))
344
 
345
   "Accessors of [LAMB-EQ][class]"
346
   (ltm   (pax:method () (lamb-eq)))
347
   (rtm   (pax:method () (lamb-eq)))
348
   (ttype (pax:method () (lamb-eq)))
349
 
350
   "Accessors of [LAMB-LT][class]"
351
   (ltm   (pax:method () (lamb-lt)))
352
   (rtm   (pax:method () (lamb-lt)))
353
   (ttype (pax:method () (lamb-lt)))
354
 
355
   "Accessors of [MODULO][class]"
356
   (ltm   (pax:method () (modulo)))
357
   (rtm   (pax:method () (modulo)))
358
   (ttype (pax:method () (modulo)))
359
 
360
   (tcod pax:generic-function)
361
   (tdom pax:generic-function)
362
   (term pax:generic-function)
363
   (rty pax:generic-function)
364
   (lty pax:generic-function)
365
   (ltm pax:generic-function)
366
   (rtm pax:generic-function)
367
   (on pax:generic-function)
368
   (fun pax:generic-function)
369
   (pos pax:generic-function)
370
   (ttype pax:generic-function)
371
   (bitv pax:generic-function))
372
 
373
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
374
 ;; Geb Package Documentation
375
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
376
 
377
 (in-package :geb.spec)
378
 
379
 (pax:defsection @geb-categories (:title "Core Category")
380
   "The underlying category of GEB. With @GEB-SUBSTMU covering the
381
 shapes and forms (GEB-DOCS/DOCS:@OBJECTS) of data while @GEB-SUBSTMORPH
382
 deals with concrete GEB-DOCS/DOCS:@MORPHISMS within the category.
383
 
384
 From this category, most abstractions will be made, with
385
 [SUBSTOBJ][type] serving as a concrete type layout, with
386
 [SUBSTMORPH][type] serving as the morphisms between different
387
 [SUBSTOBJ][type] types. This category is equivalent to
388
 [finset](https://ncatlab.org/nlab/show/FinSet).
389
 
390
 A good example of this category at work can be found within the
391
 GEB-BOOL::@GEB-BOOL section."
392
   (@geb-substmu    pax:section)
393
   (@geb-substmorph pax:section)
394
   (@geb-realized   pax:section))
395
 
396
 (pax:defsection @geb-substmu (:title "Subst Obj")
397
   "This section covers the objects of the [SUBSTMORPH][type]
398
 category. Note that [SUBSTOBJ][type] refers to the
399
 [GEB-DOCS/DOCS:@CLOSED-TYPE], whereas [\\<SUBSTOBJ\\>][class] refers
400
 to the [GEB-DOCS/DOCS:@OPEN-TYPE] that allows for user extension."
401
   (substobj   pax:type)
402
   (<substobj> pax:class)
403
   "[SUBSTOBJ][type] type is not a constructor itself, instead it's
404
 best viewed as the sum type, with the types below forming the
405
 constructors for the term. In ML we would write it similarly to:
406
 
407
 ```haskell
408
 type substobj = so0
409
               | so1
410
               | prod
411
               | coprod
412
 ```"
413
   (prod pax:class)
414
   (coprod pax:class)
415
   (so0 pax:class)
416
   (so1 pax:class)
417
   "The @GEB-ACCESSORS specific to @GEB-SUBSTMU"
418
   (mcar (pax:method () (prod)))
419
   (mcadr (pax:method () (prod)))
420
 
421
   (mcar  (pax:method () (coprod)))
422
   (mcadr (pax:method () (coprod))))
423
 
424
 (pax:defsection @geb-realized (:title "Realized Subst Objs")
425
   "This section covers the [REALIZED-OBJECT][TYPE] type. This
426
 represents a realized [SUBSTOBJ][type] term.
427
 
428
 The [REALIZED-OBJECT][TYPE] is not a real constructor but rather a sum
429
 type for the following type
430
 
431
 ```lisp
432
 (deftype realized-object () `(or left right list so1 so0))
433
 ```
434
 
435
 In ML we would have written something like
436
 
437
 ```haskell
438
 type realized-object = so0
439
                      | so1
440
                      | list
441
                      | left
442
                      | right
443
 ```"
444
   (realized-object pax:type)
445
   (left  pax:class)
446
   (right pax:class)
447
   (left  pax:function)
448
   (right pax:function))
449
 
450
 (pax:defsection @geb-substmorph (:title "Subst Morph")
451
   "The overarching types that categorizes the [SUBSTMORPH][type]
452
 category. Note that [SUBSTMORPH][type] refers to the
453
 [GEB-DOCS/DOCS:@CLOSED-TYPE], whereas [\\<SUBSTMORPH\\>][class] refers
454
 to the [GEB-DOCS/DOCS:@OPEN-TYPE] that allows for user extension."
455
   (substmorph   pax:type)
456
   (<substmorph> pax:class)
457
   "[SUBSTMORPH][type] type is not a constructor itself, instead it's
458
 best viewed as the sum type, with the types below forming the
459
 constructors for the term. In ML we would write it similarly to:
460
 
461
 ```haskell
462
 type substmorph = comp
463
                 | substobj
464
                 | case
465
                 | init
466
                 | terminal
467
                 | pair
468
                 | distribute
469
                 | inject-left
470
                 | inject-right
471
                 | project-left
472
                 | project-right
473
 ```
474
 
475
 Note that an instance of [SUBSTOBJ][type], acts like the identity
476
 morphism to the layout specified by the given [SUBSTOBJ][type]. Thus
477
 we can view this as automatically lifting a [SUBSTOBJ][type] into a
478
 [SUBSTMORPH][type]"
479
   (comp          pax:class)
480
   (case          pax:class)
481
   (init          pax:class)
482
   (terminal      pax:class)
483
   (pair          pax:class)
484
   (distribute    pax:class)
485
   (inject-left   pax:class)
486
   (inject-right  pax:class)
487
   (project-left  pax:class)
488
   (project-right pax:class)
489
   (functor       pax:class)
490
   "The @GEB-ACCESSORS specific to @GEB-SUBSTMORPH"
491
   (mcar  (pax:method () (comp)))
492
   (mcadr (pax:method () (comp)))
493
 
494
   (obj (pax:method () (init)))
495
 
496
   (obj (pax:method () (init)))
497
 
498
   (mcar  (pax:method () (case)))
499
   (mcadr (pax:method () (case)))
500
 
501
   (mcar (pax:method () (pair)))
502
   (mcdr (pax:method () (pair)))
503
 
504
   (mcar   (pax:method () (distribute)))
505
   (mcadr  (pax:method () (distribute)))
506
   (mcaddr (pax:method () (distribute)))
507
 
508
   (mcar  (pax:method () (inject-left)))
509
   (mcadr (pax:method () (inject-left)))
510
 
511
   (mcar  (pax:method () (inject-right)))
512
   (mcadr (pax:method () (inject-right)))
513
 
514
   (mcar  (pax:method () (project-left)))
515
   (mcadr (pax:method () (project-left)))
516
 
517
   (mcar  (pax:method () (project-right)))
518
   (mcadr (pax:method () (project-right))))
519
 
520
 (pax:defsection @geb-constructors (:title "Constructors")
521
   "The API for creating GEB terms. All the functions and variables
522
    here relate to instantiating a term"
523
   (*so0* pax:variable)
524
   (*so1* pax:variable)
525
   "More Ergonomic API variants for *SO0* and *SO1*"
526
   (so0 pax:symbol-macro)
527
   (so1 pax:symbol-macro)
528
   (alias pax:macro)
529
   (make-alias pax:function)
530
   (has-aliasp pax:function)
531
   (<-left pax:function)
532
   (<-right pax:function)
533
   (->left pax:function)
534
   (->right pax:function)
535
   (mcase pax:function)
536
   (make-functor pax:function))
537
 
538
 (in-package :geb.extension.spec)
539
 
540
 (pax:defsection @geb-extensions (:title "Extension Sets for Categories")
541
   "This package contains many extensions one may see over the codebase.
542
 
543
 Each extension adds an unique feature to the categories they are
544
 extending. To learn more, read about the individual extension you are
545
 interested in."
546
   "Common Sub expressions represent repeat logic that can be found
547
 throughout any piece of code"
548
   (common-sub-expression      pax:class)
549
   (make-common-sub-expression pax:function)
550
   "The Opaque extension lets users write categorical objects and
551
   morphisms where their implementation hide the specifics of what
552
   types they are operating over"
553
   (opaque       pax:class)
554
   (reference    pax:class)
555
   (opaque-morph pax:class)
556
   (code  (pax:method () (opaque-morph)))
557
   (dom   (pax:method () (opaque-morph)))
558
   (codom (pax:method () (opaque-morph)))
559
   (code  (pax:method () (opaque)))
560
   (name  (pax:method () (opaque)))
561
   (name  (pax:method () (reference)))
562
   (reference    pax:function)
563
   (opaque-morph pax:function)
564
   (opaque       pax:function)
565
   "The Natural Object/Morphism extension allows to expand the core Geb category
566
    with additional constructors standing in for bt-sequence representation of
567
    natural numbers along with basic operation relating to those."
568
   (natobj       pax:type)
569
   (<natobj>     pax:class)
570
 
571
   (nat-width    pax:class)
572
 
573
   (num   (pax:method () (nat-width)))
574
 
575
   (nat-width    pax:function)
576
 
577
   (natmorph     pax:type)
578
   (<natmorph>   pax:class)
579
 
580
   (nat-add         pax:class)
581
   (nat-mult        pax:class)
582
   (nat-sub         pax:class)
583
   (nat-div         pax:class)
584
   (nat-const       pax:class)
585
   (nat-inj         pax:class)
586
   (nat-concat      pax:class)
587
   (one-bit-to-bool pax:class)
588
   (nat-decompose   pax:class)
589
   (nat-eq          pax:class)
590
   (nat-lt          pax:class)
591
   (nat-mod         pax:class)
592
 
593
   (num       (pax:method () (nat-add)))
594
   (num       (pax:method () (nat-mult)))
595
   (num       (pax:method () (nat-sub)))
596
   (num       (pax:method () (nat-div)))
597
   (num       (pax:method () (nat-const)))
598
   (pos       (pax:method () (nat-const)))
599
   (num       (pax:method () (nat-inj)))
600
   (num-left  (pax:method () (nat-concat)))
601
   (num-right (pax:method () (nat-concat)))
602
   (num       (pax:method () (nat-decompose)))
603
   (num       (pax:method () (nat-eq)))
604
   (num       (pax:method () (nat-lt)))
605
   (num       (pax:method () (nat-mod)))
606
 
607
   (nat-add         pax:function)
608
   (nat-mult        pax:function)
609
   (nat-sub         pax:function)
610
   (nat-div         pax:function)
611
   (nat-const       pax:function)
612
   (nat-inj         pax:function)
613
   (nat-concat      pax:function)
614
   (one-bit-to-bool pax:function)
615
   (nat-decompose   pax:function)
616
   (nat-eq          pax:function)
617
   (nat-lt          pax:function)
618
   (nat-mod         pax:function)
619
 
620
   (num          pax:generic-function)
621
   (pos          pax:generic-function)
622
   (num-left     pax:generic-function)
623
   (num-right    pax:generic-function)
624
 
625
   (*one-bit-to-bool* pax:variable)
626
   (one-bit-to-bool   pax:symbol-macro))
627
 
628
 �