Implement self-documenting ‘network structures’

In contrast to scheme-bytestructures and
(gnu gnunet utils netstruct), this allows associating
a synopsis, a documention string (docstring) and arbitrary
properties with structures and fields.

Code compilation should be faster now as well and the
compiled '.go' should be smaller due to less excessive
use of syntax-rules.

TODO: update old modules

* Makefile.am (modules): compile new modules
  gnu/gnunet/netstruct/procedural.scm and
  gnu/gnunet/netstruct/syntactic.scm.
* README.org (Network Structures): document new modules.
* gnu/gnunet/crypto/struct.scm: use new module.
* gnu/gnunet/hashcode/struct.scm: likewise.
* gnu/gnunet/nse/struct.scm: likewise.
* gnu/gnunet/util/struct.scm: likewise.
* gnu/gnunet/netstruct/procedural.scm: new module
  for defining and using network structures
  procedurally.
* gnu/gnunet/netstruct/syntactic.scm: likewise,
  but syntactically and with some inlining.

1 files changed, 39 insertions, 30 deletions

diff --git a/gnu/gnunet/util/struct.scm b/gnu/gnunet/util/struct.scm
index 46323af..abec52b 100644
--- a/gnu/gnunet/util/struct.scm
+++ b/gnu/gnunet/util/struct.scm
@@ -20,41 +20,50 @@
 ;; Brief: many network structures, that would otherwise result in very
 ;; small source files if each was put in their own module.
 (define-library (gnu gnunet util struct)
-  (export /:message-header /:operation-result)
-  (import (gnu gnunet utils netstruct)
-          (only (rnrs base) begin define-syntax))
+  (export /uuid
+          /:message-header /:operation-result /async-scope-id)
+  (import (only (gnu gnunet netstruct syntactic)
+                define-type structure/packed)
+          (only (gnu gnunet netstruct procedural)
+                u8vector u16/big u32/big u64/big)
+          (only (rnrs base) begin))
   (begin
-    ; A UUID, a 128 bit random value
-    (define-syntax /uuid
+    (define-type /uuid
       (structure/packed
-       ;; 128 random bits
-       ;;  (This is represented as an array of uint32 in GNUnet)
-       ("value/u8" (u8vector 16))))
+       (synopsis "A UUID, a 128 bit random value")
+       (field (value/u8 (u8vector 16))
+              (synopsis "128 random bits")
+              (documentation
+               "This is represented as an array of uint32 in GNUnet"))))
 
-    ;; Header for all communications.
-    (define-syntax /:message-header
+    (define-type /:message-header
       (structure/packed
-       ;; The length of the struct (in bytes, including the length field itself),
-       ;; in big-endian format.
-       ("size" u16/big)
-       ;; The type of the message (GNUNET_MESSAGE_TYPE_XXXX in the C
-       ;; implementation and msg:XXX:YYY:... in the Scheme implementation),
-       ;; in big-endian format.
-       ("type" u16/big)))
+       (synopsis "Header for all communications")
+       (field (size u16/big)
+              (documentation
+               "The length of the struct (in bytes, including the length
+field itself), in big-endian format."))
+       (field (type u16/big)
+              (synopsis "The type of the message")
+              (documentation
+               "The type of the message (GNUNET_MESSAGE_TYPE_XXXX in the C
+implementation and msg:XXX:YYY:... in the Scheme implementation),
+in big-endian format."))))
 
-    ;; Answer from service to client about last operation.
-    ;; Possibly followed by data.
-    (define-syntax /:operation-result
+    (define-type /:operation-result
       (structure/packed
-       ("header" /:message-header)
-       ("reserved" u32/big)
-       ;; Operation ID.
-       ("operation-id" u64/big)
-       ;; Status code for the operation.
-       ("result-code" u64/big)))
+       (synopsis "Answer from service to client about last operation")
+       (documentation "Possibly followed by data")
+       (field (header /:message-header))
+       (field (reserved u32/big))
+       (field (operation-id u64/big)
+              (synopsis "Operation ID"))
+       (field (result-code u64/big)
+              (synopsis "Status code for the operation"))))
 
-    ;; Identifier for an asynchronous execution context.
-    (define-syntax /:async-scope-id
+    (define-type /async-scope-id
       (structure/packed
-       ;; This is represented as an array of uint32_t in GNUnet.
-       ("bits/u8" (u8vector 16))))))
+       (synopsis "Identifier for an asynchronous execution context")
+       (documentation
+        "This is represented as an array of uint32_t in GNUnet.")
+       (field (bits/u8 (u8vector 16)))))))