On 2021-10-19 12:20, [email protected] wrote:
> I wanted to try it, but patch #1 does not apply.

Ah, sorry about that. Updated versions attached!

Evan
>From d7ef79a885d7fc02b2a893e3e000a30db1cac899 Mon Sep 17 00:00:00 2001
From: Evan Hanson <[email protected]>
Date: Mon, 18 Oct 2021 17:00:20 +1300
Subject: [PATCH 1/3] Simplify library requirement processing

This is a "clarity" patch that simplifies the handling of
`##core#require` forms and tries to improve the naming of a couple of
related identifiers to keep things internally consistent.

First, rename the `core-unit?` procedure to `core-library?`, since it's
used to check all library IDs encountered during compilation and not
just units.

Then, use that procedure to check whether a library should be added to
the list of `required-libraries` directly within core.scm, rather than
returning multiple values from `##sys#process-require`. This separates
the logic for determining whether something is built-in from the
compiler's handling of `##core#require` forms a little more cleanly. If
something is a `core-library?` it should _not_ be added to the list,
else it should, the result being that `required-libraries` contains only
things that needs to be treated as an extension (and thus linked from
the eggs repository), and the interpreter doesn't have to care about any
of these decisions at all.

Then, because what we're building is really a list of _extensions_ that
need to be linked, rename `required-libraries` to `required-extensions`.

And finally, drop the list of `builtin-features`, which do not actually
need any special treatment from a library-loading point of view.
---
 batch-driver.scm |  4 ++--
 core.scm         | 23 ++++++++++-------------
 eval.scm         | 45 +++++++++++++++++----------------------------
 3 files changed, 29 insertions(+), 43 deletions(-)

diff --git a/batch-driver.scm b/batch-driver.scm
index 6f1d5f56..5ca2eedc 100644
--- a/batch-driver.scm
+++ b/batch-driver.scm
@@ -676,7 +676,7 @@
               (initialize-analysis-database)
 
               ;; collect requirements and load inline files
-              (let ((extensions required-libraries))
+              (let ((extensions required-extensions))
                 (when enable-inline-files
                   (for-each
                    (lambda (id)
@@ -851,7 +851,7 @@
 
                               ;; generate link file
                              (when emit-link-file
-                               (let ((exts required-libraries))
+                               (let ((exts required-extensions))
                                  (dribble "generating link file `~a' ..." 
emit-link-file)
                                  (with-output-to-file emit-link-file (cut pp 
exts))))
 
diff --git a/core.scm b/core.scm
index 0b980913..e35e40ca 100644
--- a/core.scm
+++ b/core.scm
@@ -315,7 +315,7 @@
      extended-bindings standard-bindings
 
      ;; Non-booleans set and read by the (batch) driver
-     required-libraries linked-libraries used-libraries
+     required-extensions linked-libraries used-libraries
 
      ;; non-booleans set by the (batch) driver, and read by the (c) backend
      target-heap-size target-stack-size unit-name used-units
@@ -450,7 +450,7 @@
 (define callback-names '())
 (define toplevel-scope #t)
 (define toplevel-lambda-id #f)
-(define required-libraries '())
+(define required-extensions '())
 (define linked-libraries '())
 (define used-libraries '())
 
@@ -738,17 +738,14 @@
                        ((##core#require)
                         (let ((lib (cadr x))
                               (mod (and (pair? (cddr x)) (caddr x))))
-                          (let-values (((reqform builtin) 
-                                          (##sys#process-require
-                                                   lib mod
-                                           (if (or (memq lib linked-libraries) 
-                                                   static-extensions)
-                                             'static
-                                             'dynamic))))
-                             (unless builtin
-                               (set! required-libraries 
-                                 (lset-adjoin/eq? required-libraries lib)))
-                             (walk reqform e dest ldest h ln #f))))
+                          (unless (chicken.load#core-library? lib)
+                            (set! required-extensions (lset-adjoin/eq? 
required-extensions lib)))
+                          (walk (##sys#process-require
+                                 lib mod
+                                 (if (or (memq lib linked-libraries) 
static-extensions)
+                                     'static
+                                     'dynamic))
+                                e dest ldest h ln #f)))
 
                        ((##core#let)
                         (let* ((bindings (cadr x))
diff --git a/eval.scm b/eval.scm
index 30c651cd..0e756394 100644
--- a/eval.scm
+++ b/eval.scm
@@ -596,9 +596,8 @@
 
                         [(##core#require)
                          (let ((lib (cadr x))
-                                (mod (and (pair? (cddr x)) (caddr x))))
-                            (let-values (((reqform _) (##sys#process-require 
lib mod #f)))
-                             (compile reqform e #f tf cntr #f)))]
+                               (mod (and (pair? (cddr x)) (caddr x))))
+                           (compile (##sys#process-require lib mod #f) e #f tf 
cntr #f))]
 
                         [(##core#elaborationtimeonly 
##core#elaborationtimetoo) ; <- Note this!
                          (##sys#eval/meta (cadr x))
@@ -904,6 +903,7 @@
 
 ;;; Core unit information
 
+;; this maps built-in library names to require forms when the mapping isn't 1:1
 (define-constant core-unit-requirements
   '((chicken.foreign
      . (##core#require-for-syntax chicken-ffi-syntax))
@@ -912,6 +912,9 @@
        (##core#require-for-syntax chicken-syntax)
        (##core#require library)))))
 
+;; this list contains built-in units that are provided by libchicken
+;; and should not be treated as separate extension libraries during
+;; linking (they are omitted from types/inline/link files etc.)
 (define-constant core-units
   '(chicken-syntax chicken-ffi-syntax continuation data-structures
     debugger-client eval eval-modules expand extras file internal
@@ -934,17 +937,10 @@
 
 (define ##sys#load-dynamic-extension default-load-library-extension)
 
-(define (chicken.load#core-unit? id) ; used by batch-driver.scm
+(define (chicken.load#core-library? id) ; used by core.scm
   (or (memq id core-units)
       (assq id core-unit-requirements)))
 
-; these are actually in unit extras, but that is used by default
-
-(define-constant builtin-features
-  '(srfi-30 srfi-46 srfi-61 srfi-62                     ; runtime
-    srfi-0 srfi-2 srfi-8 srfi-9 srfi-11 srfi-15 srfi-16 ; syntax
-    srfi-17 srfi-26 srfi-31 srfi-55 srfi-87 srfi-88))   ; syntax cont
-
 (define default-dynamic-load-libraries
   (case (software-version)
     ((cygwin) cygwin-default-dynamic-load-libraries)
@@ -1251,26 +1247,19 @@
 (define (##sys#process-require lib mod compile-mode)
   (let ((mod (or (eq? lib mod) mod)))
     (cond
-      ((assq lib core-unit-requirements) => 
-        (lambda (a) (values (cdr a) #t)))
-      ((memq lib builtin-features) 
-        (values '(##core#undefined) #t))
+      ((assq lib core-unit-requirements) => cdr)
       ((memq lib core-units)
-        (values
-          (if compile-mode
-             `(##core#callunit ,lib)
-             `(chicken.load#load-unit (##core#quote ,lib)
-                                      (##core#quote #f)
-                                      (##core#quote #f)))
-          #t))
+       (if compile-mode
+           `(##core#callunit ,lib)
+           `(chicken.load#load-unit (##core#quote ,lib)
+                                    (##core#quote #f)
+                                    (##core#quote #f))))
       ((eq? compile-mode 'static)
-       (values `(##core#callunit ,lib) #f))
+       `(##core#callunit ,lib))
       (else
-       (values
-          `(chicken.load#load-extension (##core#quote ,lib)
-                                       (##core#quote ,mod)
-                                       (##core#quote #f))
-          #f)))))
+       `(chicken.load#load-extension (##core#quote ,lib)
+                                     (##core#quote ,mod)
+                                     (##core#quote #f))))))
 
 ;;; Find included file:
 
-- 
2.31.1

>From c671683ede94443a631e6b1f86e444aa0156c7e9 Mon Sep 17 00:00:00 2001
From: Evan Hanson <[email protected]>
Date: Mon, 18 Oct 2021 17:25:54 +1300
Subject: [PATCH 2/3] Make "primitive modules" avoid triggering any code
 loading

This changes the way code loading is done, or rather _not_ done, for
so-called "primitive modules". Previously, these modules would be given
a library name that matches their module name, which would be passed to
the compiler, which would process a `##core#require` form only to decide
decide there's nothing to do (usually resulting in a `##core#undefined`
node). Really, this is useless work, since there is no library code to
load for any of these modules, and we know that up front. Instead, we
should just set the `library` field for these modules to false, to
indicate that they provide only syntax and don't need to load any code.
This is what's done by the change to `##sys#register-primitive-module`.

The two modules that are currently registered as "primitive modules" but
_do_ need to load code are chicken.foreign and chicken.condition, which
are handled as special cases in eval.scm. To keep the current behaviour,
we change these to use `##sys#register-core-module`, and explicitly set
their `library` field to the current value, i.e. the module name.

Note the changes in the patch do not only affect the modules defined
within modules.scm but also the chicken.csi module, for which the
`##sys#register-primitive-module` procedure is used in its import file.
As such, this fixes the problem of chicken.csi appearing in link files
because, as a primitive module, it will not create a `##core#require`
node and so will not end up in the list of `required-extensions`.

Also, drop the module alias for the srfi-88 library, which is already
defined (and more correctly) at modules.scm:1180.
---
 chicken.condition.import.scm |  2 +-
 chicken.foreign.import.scm   |  3 ++-
 modules.scm                  | 18 +++++++++---------
 3 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/chicken.condition.import.scm b/chicken.condition.import.scm
index 200d0141..0d72a84b 100644
--- a/chicken.condition.import.scm
+++ b/chicken.condition.import.scm
@@ -25,7 +25,7 @@
 
 (##sys#register-core-module
  'chicken.condition
- 'library
+ 'chicken.condition ; mapped to distinct run/compile-time requirements in eval 
unit
  '((abort . chicken.condition#abort)
    (signal . chicken.condition#signal)
    (current-exception-handler . chicken.condition#current-exception-handler)
diff --git a/chicken.foreign.import.scm b/chicken.foreign.import.scm
index 03c7c535..d7ede987 100644
--- a/chicken.foreign.import.scm
+++ b/chicken.foreign.import.scm
@@ -24,7 +24,8 @@
 ; POSSIBILITY OF SUCH DAMAGE.
 
 
-(##sys#register-primitive-module
+(##sys#register-core-module
  'chicken.foreign
+ 'chicken.foreign ; mapped to distinct run/compile-time requirements in eval 
unit
  '()
  ##sys#chicken-ffi-macro-environment)
diff --git a/modules.scm b/modules.scm
index cbe48fe7..c89b0af6 100644
--- a/modules.scm
+++ b/modules.scm
@@ -442,9 +442,10 @@
     (set! ##sys#module-table (cons (cons name mod) ##sys#module-table)) 
     mod))
 
-;; same as register-core-module, but uses module's name as its library
+;; same as register-core-module (above) but does not load any code,
+;; used to register modules that provide only syntax
 (define (##sys#register-primitive-module name vexports #!optional (sexports 
'()))
-  (##sys#register-core-module name name vexports sexports))
+  (##sys#register-core-module name #f vexports sexports))
 
 (define (find-export sym mod indirect)
   (let ((exports (module-export-list mod)))
@@ -1095,19 +1096,18 @@
   (##sys#register-core-module 'r5rs-null #f '() r4rs-syntax))
 
 (##sys#register-module-alias 'r5rs 'scheme)
-(##sys#register-module-alias 'srfi-88 'chicken.keyword)
 
 (define-inline (se-subset names env) (map (cut assq <> env) names))
 
 ;; Hack for library.scm to use macros from modules it defines itself.
-(##sys#register-core-module
- 'chicken.internal.syntax #f '() (##sys#macro-environment))
+(##sys#register-primitive-module
+ 'chicken.internal.syntax '() (##sys#macro-environment))
 
-(##sys#register-core-module
- 'chicken.module #f '() ##sys#chicken.module-macro-environment)
+(##sys#register-primitive-module
+ 'chicken.module '() ##sys#chicken.module-macro-environment)
 
-(##sys#register-core-module
- 'chicken.type #f '() ##sys#chicken.type-macro-environment)
+(##sys#register-primitive-module
+ 'chicken.type '() ##sys#chicken.type-macro-environment)
 
 (##sys#register-primitive-module
  'srfi-0 '() (se-subset '(cond-expand) ##sys#default-macro-environment))
-- 
2.31.1

>From e60d3e78d2a162e8916c6059f6b0f7a5917dcb3c Mon Sep 17 00:00:00 2001
From: Evan Hanson <[email protected]>
Date: Mon, 18 Oct 2021 17:48:37 +1300
Subject: [PATCH 3/3] Update SRFI feature identifiers and documentation

Move all feature identifiers that are registered in chicken-syntax.scm
and expand.scm into the correct files and update the documentation that
relates to built-in features.

Add a section to "Included modules" that lists the SRFI modules that can
be imported. Also note that some SRFI identifiers _cannot_ be imported
because they are fully built-in and not defined by any module.
---
 chicken-syntax.scm                  |  5 +++--
 expand.scm                          |  8 ++++----
 library.scm                         |  4 ++--
 manual/Extensions to the standard   | 31 +++++++++++++++++++----------
 manual/Included modules             | 27 +++++++++++++++++++++++++
 manual/Module (chicken base)        |  4 ++--
 manual/Module (chicken platform)    |  8 +-------
 manual/Module (chicken read-syntax) |  2 ++
 manual/Module srfi-4                |  2 ++
 9 files changed, 63 insertions(+), 28 deletions(-)

diff --git a/chicken-syntax.scm b/chicken-syntax.scm
index cde8e9e6..6ebb9d10 100644
--- a/chicken-syntax.scm
+++ b/chicken-syntax.scm
@@ -43,7 +43,8 @@
         (chicken base)
         (chicken fixnum)
         (chicken syntax)
-        (chicken internal))
+        (chicken internal)
+        (chicken platform))
 
 (include "common-declarations.scm")
 (include "mini-srfi-1.scm")
@@ -1307,4 +1308,4 @@
 
 ;; register features
 
-(chicken.platform#register-feature! 'srfi-8 'srfi-11 'srfi-15 'srfi-16 
'srfi-26 'srfi-31)
+(register-feature! 'srfi-2 'srfi-8 'srfi-9 'srfi-11 'srfi-15 'srfi-16 'srfi-26 
'srfi-31 'srfi-55)
diff --git a/expand.scm b/expand.scm
index e815a2b9..17dc7549 100644
--- a/expand.scm
+++ b/expand.scm
@@ -63,10 +63,6 @@
            (cons (car a) (if (symbol? (cdr a)) (cdr a) '<macro>)))
          ?se))))
 
-(set! ##sys#features
-  (append '(#:srfi-0 #:srfi-2 #:srfi-6 #:srfi-9 #:srfi-46 #:srfi-55 #:srfi-61)
-         ##sys#features))
-
 (define-alias dd d)
 (define-alias dm d)
 (define-alias dx d)
@@ -1585,3 +1581,7 @@
   (fixup-macro-environment (##sys#macro-environment)))
 
 (define ##sys#meta-macro-environment (make-parameter 
(##sys#macro-environment)))
+
+;; register features
+
+(register-feature! 'srfi-0 'srfi-46 'srfi-61 'srfi-87)
diff --git a/library.scm b/library.scm
index 95e5797b..6c6a6942 100644
--- a/library.scm
+++ b/library.scm
@@ -6539,8 +6539,8 @@ static C_word C_fcall C_setenv(C_word x, C_word y) {
 
 (define ##sys#features
   '(#:chicken
-    #:srfi-6 #:srfi-8 #:srfi-12 #:srfi-17 #:srfi-23 #:srfi-30
-    #:srfi-39 #:srfi-62 #:srfi-87 #:srfi-88 #:full-numeric-tower))
+    #:srfi-6 #:srfi-12 #:srfi-17 #:srfi-23 #:srfi-30
+    #:srfi-39 #:srfi-62 #:srfi-88 #:full-numeric-tower))
 
 ;; Add system features:
 
diff --git a/manual/Extensions to the standard b/manual/Extensions to the 
standard
index 66ef6c64..a1ccdf29 100644
--- a/manual/Extensions to the standard 
+++ b/manual/Extensions to the standard 
@@ -28,17 +28,26 @@ always present in a module, even without imports.
 
 Expands by selecting feature clauses. This form is allowed to appear in 
non-toplevel expressions.
 
-Predefined feature-identifiers are "situation" specific:
-
-; compile : {{chicken}}, {{compiling}}, {{library}}, {{eval}}, {{extras}}, 
{{regex}}, {{srfi-0}}, {{srfi-2}}, {{srfi-4}}, {{srfi-6}}, {{srfi-8}}, 
{{srfi-9}}, {{srfi-10}}, {{srfi-11}}, {{srfi-12}}, {{srfi-15}}, {{srfi-16}}, 
{{srfi-17}}, {{srfi-23}}, {{srfi-26}}, {{srfi-28}}, {{srfi-30}}, {{srfi-31}}, 
{{srfi-39}}, {{srfi-55}}, {{srfi-61}}, {{srfi-62}}
-
-; load : {{chicken}}, {{extras}}, {{srfi-0}}, {{srfi-2}}, {{srfi-6}}, 
{{srfi-8}}, {{srfi-9}}, {{srfi-10}}, {{srfi-12}}, {{srfi-17}}, {{srfi-23}}, 
{{srfi-28}}, {{srfi-30}}, {{srfi-39}}, {{srfi-55}}, {{srfi-61}}, {{srfi-62}}. 
{{library}} is implicit.
-
-; eval : {{csi}}, {{chicken}}, {{extras}}, {{srfi-0}}, {{srfi-2}}, {{srfi-6}}, 
{{srfi-8}}, {{srfi-9}}, {{srfi-10}}, {{srfi-11}}, {{srfi-12}}, {{srfi-15}}, 
{{srfi-16}}, {{srfi-17}}, {{srfi-23}}, {{srfi-26}}, {{srfi-28}}, {{srfi-30}}, 
{{srfi-31}}, {{srfi-39}}, {{srfi-55}}, {{srfi-61}}, {{srfi-62}}. {{library}} is 
implicit.
-
-The following feature-identifier classes are available in all situations: 
{{(machine-byte-order)}}, {{(machine-type)}}, {{(software-type)}}, 
{{(software-version)}}, where the actual feature-identifier is platform 
dependent.
-
-In addition the following feature-identifiers may exist: {{cross-chicken}}, 
{{dload}}, {{manyargs}}, {{ptables}}.
+The following features are built-in and always available by default:
+{{chicken}}, {{srfi-0}}, {{srfi-2}}, {{srfi-6}}, {{srfi-8}}, {{srfi-9}},
+{{srfi-11}}, {{srfi-12}}, {{srfi-15}}, {{srfi-16}}, {{srfi-17}}, {{srfi-23}},
+{{srfi-26}}, {{srfi-28}}, {{srfi-30}}, {{srfi-31}}, {{srfi-39}}, {{srfi-46}},
+{{srfi-55}}, {{srfi-61}}, {{srfi-62}}, {{srfi-87}}, {{srfi-88}}.
+
+There are also situation-specific feature identifiers: {{compiling}} during
+compilation, {{csi}} when running in the interpreter, and 
{{compiler-extension}}
+when running within the compiler.
+
+The following feature-identifier classes are available in all situations:
+{{(machine-byte-order)}}, {{(machine-type)}}, {{(software-type)}},
+{{(software-version)}}, where the actual feature-identifier is platform
+dependent.
+
+Platform endianness is indicated by the {{little-endian}} and {{big-endian}}
+features.
+
+In addition the following feature-identifiers may exist: {{cross-chicken}},
+{{dload}}, {{gchooks}}, {{ptables}}, {{case-insensitive}}.
 
 For further information, see the documentation for
 [[http://srfi.schemers.org/srfi-0/srfi-0.html|SRFI-0]].
diff --git a/manual/Included modules b/manual/Included modules
index 2a4e9a28..256b3f09 100644
--- a/manual/Included modules   
+++ b/manual/Included modules   
@@ -55,6 +55,33 @@ additional modules through the [[Extensions|eggs]] system.
 * [[Module (chicken time posix)]] : Manipulating POSIX time
 * [[Module (chicken type)]] : Defining and using static typing information
 
+In addition to the core modules listed above, the following SRFI modules can be
+imported. These provide access to identifiers described by the SRFI, but which
+may already be defined by other parts of CHICKEN's standard library.
+
+* Module srfi-0 : Feature-based conditional expansion construct
+* Module srfi-2 : AND-LET*: an AND with local bindings, a guarded LET* special 
form
+* Module srfi-6 : Basic String Ports
+* Module srfi-8 : receive: Binding to multiple values
+* Module srfi-9 : Defining Record Types
+* Module srfi-10 : #, external form
+* Module srfi-11 : Syntax for receiving multiple values
+* Module srfi-12 : Exception Handling
+* Module srfi-15 : Syntax for dynamic scoping
+* Module srfi-16 : Syntax for procedures of variable arity
+* Module srfi-17 : Generalized set!
+* Module srfi-23 : Error reporting mechanism
+* Module srfi-26 : Notation for Specializing Parameters without Currying
+* Module srfi-28 : Basic Format Strings
+* Module srfi-31 : A special form `rec' for recursive evaluation
+* Module srfi-39 : Parameter objects
+* Module srfi-55 : require-extension
+* Module srfi-88 : Keyword objects
+* Module srfi-98 : An interface to access environment variables
+
+Other SRFI features may be supported but do not correspond to any importable 
module.
+Refer to {{cond-expand}} for a list of non-module SRFI feature identifiers.
+
 ---
 Previous: [[Extensions to the standard]]
 
diff --git a/manual/Module (chicken base) b/manual/Module (chicken base)
index 8abc07e7..f8bb1eea 100644
--- a/manual/Module (chicken base)      
+++ b/manual/Module (chicken base)      
@@ -1267,7 +1267,7 @@ extensions.
 During interpretation/evaluation {{require-library}} performs one of the
 following:
 
-* If {{ID}} names a built-in feature {{chicken srfi-0 srfi-2 srfi-6 srfi-8 
srfi-9 srfi-10 srfi-17 srfi-23 srfi-30 srfi-39 srfi-55}}, then nothing is done.
+* If {{ID}} names a built-in feature, then nothing is done.
 * If {{ID}} names one of the syntactic extensions {{chicken-syntax 
chicken-ffi-syntax}}, then this extension will be loaded.
 * If {{ID}} names one of the core library units shipped with CHICKEN, then a 
{{(load-library 'ID)}} will be performed.
 * If {{ID}} names an installed extension with the {{syntax}} or 
{{require-at-runtime}} attribute, then the extensions is loaded at 
compile-time, probably doing a run-time {{(require ...)}} for any run-time 
requirements.
@@ -1275,7 +1275,7 @@ following:
 
 During compilation, one of the following happens instead:
 
-* If {{ID}} names a built-in feature {{chicken srfi-0 srfi-2 srfi-6 srfi-8 
srfi-9 srfi-10 srfi-17 srfi-23 srfi-30 srfi-39 srfi-55}}, then nothing is done.
+* If {{ID}} names a built-in feature, then nothing is done.
 * If {{ID}} names one of the syntactic extensions {{chicken-syntax 
chicken-ffi-syntax}}, then this extension will be loaded at compile-time, 
making the syntactic extensions available in compiled code.
 * If {{ID}} names one of the core library units shipped with CHICKEN, or if 
the option {{-uses ID}} has been passed to the compiler, then a {{(declare 
(uses ID))}} is generated.
 * If {{ID}} names an installed extension with the {{syntax}} or 
{{require-at-runtime}} attribute, then the extension is loaded at compile-time, 
and code is emitted to {{(require ...)}} any needed run-time requirements.
diff --git a/manual/Module (chicken platform) b/manual/Module (chicken platform)
index 47566d6b..7be85317 100644
--- a/manual/Module (chicken platform)  
+++ b/manual/Module (chicken platform)  
@@ -157,17 +157,11 @@ process is currently running, which is one of the 
following:
 
 === Feature identifiers
 
-
 CHICKEN maintains a global list of ''features'' naming functionality available
 in the current system. Additionally the {{cond-expand}} form accesses this
 feature list to infer what features are provided. Predefined features are
 {{chicken}}, and the SRFIs (Scheme Request For Implementation) provided by the
-base system: {{srfi-23, srfi-30, srfi-39}}. If the {{eval}} unit
-is used (the default), the features {{srfi-0, srfi-2, srfi-6, srfi-8, srfi-9}}
-and {{srfi-10}} are defined. When compiling code (during compile-time) the
-feature {{compiling}} is registered. When evaluating code in the interpreter
-(csi), the feature {{csi}} is registered.
-
+base system. Refer to {{cond-expand}} for a full list of predefined 
identifiers.
 
 ==== features
 
diff --git a/manual/Module (chicken read-syntax) b/manual/Module (chicken 
read-syntax)
index 00429878..a5fc716a 100644
--- a/manual/Module (chicken read-syntax)       
+++ b/manual/Module (chicken read-syntax)       
@@ -6,6 +6,8 @@
 This module provides procedures which can be used to extend the reader
 with custom read syntax.
 
+When loaded, the feature identifier {{srfi-10}} is defined.
+
 === define-reader-ctor
 
 <procedure>(define-reader-ctor SYMBOL PROC)</procedure>
diff --git a/manual/Module srfi-4 b/manual/Module srfi-4
index ccfe512d..9eb00002 100644
--- a/manual/Module srfi-4      
+++ b/manual/Module srfi-4      
@@ -6,6 +6,8 @@
 Homogeneous numeric vector datatypes.  Also see the
 [[http://srfi.schemers.org/srfi-4/srfi-4.html|original SRFI-4 document]].
 
+When loaded, the feature identifier {{srfi-4}} is defined.
+
 === CHICKEN implementation specifics and extensions
 
 * Procedures for [[Module (chicken blob)|blob]] conversion, subvectors and 
vector I/O are provided.
-- 
2.31.1

Reply via email to