~ chicken-core (master) 680ec0a71860bb37f808317dd938dfd237fb41d7
commit 680ec0a71860bb37f808317dd938dfd237fb41d7
Author: felix <felix@call-with-current-continuation.org>
AuthorDate: Sat Nov 15 12:48:16 2025 +0100
Commit: felix <felix@call-with-current-continuation.org>
CommitDate: Sat Nov 15 12:48:16 2025 +0100
markup repair, remove mention of clustering
diff --git a/c-platform.scm b/c-platform.scm
index 8111ecd4..d4650f09 100644
--- a/c-platform.scm
+++ b/c-platform.scm
@@ -106,7 +106,7 @@
no-procedure-checks-for-toplevel-bindings
no-bound-checks no-procedure-checks-for-usual-bindings no-compiler-syntax
no-parentheses-synonyms r7rs-syntax emit-all-import-libraries
- strict-types clustering lfa2 debug-info
+ strict-types lfa2 debug-info
regenerate-import-libraries setup-mode
module-registration no-module-registration))
diff --git a/csc.mdoc b/csc.mdoc
index ba5e898f..4be84893 100644
--- a/csc.mdoc
+++ b/csc.mdoc
@@ -197,8 +197,6 @@ Disable procedure call checks only for usual bindings.
Disable procedure call checks for toplevel bindings.
.It Fl strict-types
Assume variable do not change their type.
-.It Fl clustering
-Combine groups of local procedures into dispatch loop.
.It Fl lfa2
Perform additional lightweight flow-analysis pass.
.It Fl unroll-limit Ar LIMIT
diff --git a/manual/Deviations from the standard b/manual/Deviations from the standard
index 4f1dcf78..ce3ec4f1 100644
--- a/manual/Deviations from the standard
+++ b/manual/Deviations from the standard
@@ -2,8 +2,6 @@
== Confirmed deviations from R7RS
-Identifiers are by default case-sensitive (see [[Using the compiler]]).
-
=== Number of arguments to procedures and macros
The maximal number of arguments that may be passed to a
diff --git a/manual/Module (scheme base) b/manual/Module (scheme base)
index b706ceb8..59d883d1 100644
--- a/manual/Module (scheme base)
+++ b/manual/Module (scheme base)
@@ -607,8 +607,8 @@ are lambda expressions and the restriction is satisfied automatically.
<macro>(letrec* <bindings> <body>) </macro>
-Syntax: <Bindings> has the form {{((<variable[1]> <init[1]>) ...)}},and
-<body>is a sequence of zero or more
+Syntax: <Bindings> has the form {{((<variable[1]> <init[1]>) ...)}}, and
+<body> is a sequence of zero or more
definitions followed by one or more expressions as described in section 4.1.4.
It is an error for a <variable> to appear more than once in the list of
variables being bound.
@@ -626,27 +626,25 @@ the value of the corresponding <variable> or the <variable> of any of the
bindings that follow it in <bindings>, it is an error. Another restriction is
that it is an error to invoke the continuation of an <init> more than once.
-{{
-;; Returns the arithmetic, geometric, and
-;; harmonic means of a nested list of numbers
-(define (means ton)
- (letrec*
- ((mean
- (lambda (f g)
- (f (/ (sum g ton) n))))
- (sum
- (lambda (g ton)
- (if (null? ton)
- (+)
- (if (number? ton)
- (g ton)
- (+ (sum g (car ton))
- (sum g (cdr ton)))))))
- (n (sum (lambda (x) 1) ton)))
- (values (mean values values)
- (mean exp log)
- (mean / /))))
-}}
+ ;; Returns the arithmetic, geometric, and
+ ;; harmonic means of a nested list of numbers
+ (define (means ton)
+ (letrec*
+ ((mean
+ (lambda (f g)
+ (f (/ (sum g ton) n))))
+ (sum
+ (lambda (g ton)
+ (if (null? ton)
+ (+)
+ (if (number? ton)
+ (g ton)
+ (+ (sum g (car ton))
+ (sum g (cdr ton)))))))
+ (n (sum (lambda (x) 1) ton)))
+ (values (mean values values)
+ (mean exp log)
+ (mean / /))))
Evaluating {{(means '(3 (1 4)))}} returns three values: 8/3, 2.28942848510666
(approximately), and 36/19.
@@ -671,10 +669,8 @@ binding of a <variable> has <body> as its region.
It is an error if the <formals> do not match the number of values returned by
the corresponding <init>.
-{{
-(let-values (((root rem) (exact-integer-sqrt 32)))
- (* root rem)) ==> 35
-}}
+ (let-values (((root rem) (exact-integer-sqrt 32)))
+ (* root rem)) ==> 35
<macro>(let*-values <mv binding spec> <body>)</macro>
@@ -689,12 +685,10 @@ region of the bindings of each <formals> including the <init>s to its right as
well as <body>. Thus the second <init> is evaluated in an environment in which
the first set of bindings is visible and initialized, and so on.
-{{
-(let ((a 'a) (b 'b) (x 'x) (y 'y))
- (let*-values (((a b) (values x y))
- ((x y) (values a b)))
- (list a b x y))) ⟹ (x y x y)
-}}
+ (let ((a 'a) (b 'b) (x 'x) (y 'y))
+ (let*-values (((a b) (values x y))
+ ((x y) (values a b)))
+ (list a b x y))) ⟹ (x y x y)
==== Sequencing
@@ -808,7 +802,7 @@ using {{parameterize}}, which is described below.
The effect of passing arguments to a parameter object is
implementation-dependent.
-<macro>(parameterize ((<param[1]> <value[1]>) ...) <body>)</procedure>
+<syntax>(parameterize ((<param[1]> <value[1]>) ...) <body>)</syntax>
Syntax: Both <param[1]> and <value[1]> are expressions.
@@ -826,10 +820,10 @@ of the parameters are restored without passing them to the conversion
procedure. The results of the last expression in the <body> are returned as the
results of the entire parameterize expression.
- Note: If the conversion procedure is not idempotent, the results of
- (parameterize ((x (x))) ...), which appears to bind the parameter
+Note: If the conversion procedure is not idempotent, the results of
+(parameterize ((x (x))) ...), which appears to bind the parameter
- x to its current value, might not be what the user expects.
+x to its current value, might not be what the user expects.
If an implementation supports multiple threads of execution, then parameterize
must not change the associated values of any parameters in any thread other
@@ -839,27 +833,25 @@ Parameter objects can be used to specify configurable settings for a
computation without the need to pass the value to every procedure in the call
chain explicitly.
-{{
-(define radix
- (make-parameter
- 10
- (lambda (x)
- (if (and (exact-integer? x) (<= 2 x 16))
- x
- (error "invalid radix")))))
+ (define radix
+ (make-parameter
+ 10
+ (lambda (x)
+ (if (and (exact-integer? x) (<= 2 x 16))
+ x
+ (error "invalid radix")))))
-(define (f n) (number->string n (radix)))
+ (define (f n) (number->string n (radix)))
-(f 12) ==> "12"
-(parameterize ((radix 2))
- (f 12)) ==> "1100"
-(f 12) ==> "12"
+ (f 12) ==> "12"
+ (parameterize ((radix 2))
+ (f 12)) ==> "1100"
+ (f 12) ==> "12"
-(radix 16) ==> unspecified
+ (radix 16) ==> unspecified
-(parameterize ((radix 0))
- (f 12)) ==> error
-}}
+ (parameterize ((radix 0))
+ (f 12)) ==> error
==== Exception handling
@@ -877,19 +869,17 @@ invoked on the raised object within the dynamic environment of the original
call to raise or raise-continuable, except that the current exception handler
is that of the guard expression.
-{{
-(guard (condition
- ((assq 'a condition) => cdr)
- ((assq 'b condition)))
- (raise (list (cons 'a 42))))
-==> 42
-
-(guard (condition
- ((assq 'a condition) => cdr)
- ((assq 'b condition)))
- (raise (list (cons 'b 23))))
-==> (b . 23)
-}}
+ (guard (condition
+ ((assq 'a condition) => cdr)
+ ((assq 'b condition)))
+ (raise (list (cons 'a 42))))
+ ==> 42
+
+ (guard (condition
+ ((assq 'a condition) => cdr)
+ ((assq 'b condition)))
+ (raise (list (cons 'b 23))))
+ ==> (b . 23)
==== Quasiquotation
@@ -1154,7 +1144,7 @@ More formally, an input form F matches a pattern P if and only if:
* P is a vector of the form #(P[1] ... P[n]) and F is a vector of n
forms that match P[1] through P[n]; or
- • P is of the form #(P[1] ... P[k] P[e] <ellipsis> P[m+1] ... P[n]) where E is a
+* P is of the form #(P[1] ... P[k] P[e] <ellipsis> P[m+1] ... P[n]) where E is a
vector of n elements the first k of which match P[1] through P[k], whose
next m−k elements each match P[e], and whose remaining n−m elements match P
[m+1] through P[n]; or
@@ -1460,14 +1450,12 @@ Semantics: <Expression> is evaluated, and the <formals> are bound to the return
values in the same way that the <formals> in a lambda expression are matched to
the arguments in a procedure call.
-{{
-(define-values (x y) (exact-integer-sqrt 17))
-(list x y) ==> (4 1)
+ (define-values (x y) (exact-integer-sqrt 17))
+ (list x y) ==> (4 1)
-(let ()
- (define-values (x y) (values 1 2))
- (+ x y)) ==> 3
-}}
+ (let ()
+ (define-values (x y) (values 1 2))
+ (+ x y)) ==> 3
=== Syntax definitions
@@ -1589,26 +1577,22 @@ An instance of define-record-type is equivalent to the following definitions:
For instance, the following record-type definition
-{{
-(define-record-type <pare>
- (kons x y)
- pare?
- (x kar set-kar!)
- (y kdr))
-}}
+ (define-record-type <pare>
+ (kons x y)
+ pare?
+ (x kar set-kar!)
+ (y kdr))
defines kons to be a constructor, kar and kdr to be accessors, set-kar! to be a
modifier, and pare? to be a predicate for instances of <pare>.
-{{
-(pare? (kons 1 2)) ⟹ #t
- (pare? (cons 1 2)) ⟹ #f
- (kar (kons 1 2)) ⟹ 1
- (kdr (kons 1 2)) ⟹ 2
- (let ((k (kons 1 2)))
- (set-kar! k 3)
- (kar k)) ⟹ 3
-}}
+ (pare? (kons 1 2)) ⟹ #t
+ (pare? (cons 1 2)) ⟹ #f
+ (kar (kons 1 2)) ⟹ 1
+ (kdr (kons 1 2)) ⟹ 2
+ (let ((k (kons 1 2)))
+ (set-kar! k 3)
+ (kar k)) ⟹ 3
=== Libraries
@@ -2158,7 +2142,7 @@ which are encoded in the naming conventions of the arguments as
given in the procedure's signature. The conventions are as follows:
; {{obj}} : any object
-; {{list, list1, ... listj, ... list : (see "[[#pairs-and-lists|Pairs and lists]]" below)
+; {{list, list1, ... listj, ... list}} : (see "[[#pairs-and-lists|Pairs and lists]]" below)
; {{z, z1, ... zj, ...}} : complex number
; {{x, x1, ... xj, ...}} : real number
; {{y, y1, ... yj, ...}} : real number
diff --git a/manual/Module (scheme case-lambda) b/manual/Module (scheme case-lambda)
index 61578182..7bb114d0 100644
--- a/manual/Module (scheme case-lambda)
+++ b/manual/Module (scheme case-lambda)
@@ -34,4 +34,4 @@ It is an error for the arguments not to agree with the <formals> of any
---
Previous: [[Module (scheme base)]]
-Next: [[Module (scheme char))]]
+Next: [[Module (scheme char)]]
diff --git a/manual/Module (scheme file) b/manual/Module (scheme file)
index 594e14f7..800e6936 100644
--- a/manual/Module (scheme file)
+++ b/manual/Module (scheme file)
@@ -64,5 +64,4 @@ be deleted, an error that satisfies file-error? is signaled.
---
Previous: [[Module (scheme complex)]]
-Next: [[Module (scheme
- eval)]]
+Next: [[Module (scheme eval)]]
diff --git a/manual/Module (scheme lazy) b/manual/Module (scheme lazy)
index 5838bf06..f4f60890 100644
--- a/manual/Module (scheme lazy)
+++ b/manual/Module (scheme lazy)
@@ -117,7 +117,7 @@ The promise? procedure returns #t if its argument is a promise, and #f
otherwise. Note that promises are not necessarily disjoint from other Scheme
types such as procedures.
-<procedure>(make-promise obj)</promise>
+<procedure>(make-promise obj)</procedure>
The make-promise procedure returns a promise which, when forced, will return
obj. It is similar to delay, but does not delay its argument: it is a procedure
diff --git a/manual/Module scheme b/manual/Module scheme
index 89f754c0..91dd233f 100644
--- a/manual/Module scheme
+++ b/manual/Module scheme
@@ -5,7 +5,7 @@
This module is intended for backwards compatibility with older CHICKEN code
and exports a subset of the R7RS procedures in {{(scheme base)}}, {{(scheme char)}},
- {{(scheme complex)}}, {{(scheme cxr)}}, {{(scheme eval)}}, {{(scheme file)}},
+{{(scheme complex)}}, {{(scheme cxr)}}, {{(scheme eval)}}, {{(scheme file)}},
{{(scheme inexact)}}, {{(scheme lazy)}}, {{(scheme load)}},
{{(scheme read)}}, {{(scheme repl)}}, {{(scheme write)}} and all macros that correspond to
the bindings available by default in R5RS.
Trap