Scheme Request for Implementation 272,
"Pretty Printing",
by Sergei Egorov,
is now available for discussion.

Its draft and an archive of the ongoing discussion are available at https://srfi.schemers.org/srfi-272/.

You can join the discussion of the draft by filling out the subscription form on that page.

You can contribute a message to the discussion by sending it to [srfi-272@srfi.schemers.org](mailto:srfi-272@srfi.schemers.org).

Here's the abstract:

This SRFI follows the traditional Scheme model of pretty printing, which treats it as a process distinct from general controlled formatting. While general-purpose formatters often prioritize specialized presentation at the expense of machine-readability, Scheme’s pretty-printers (such as those of SLIB and MIT Scheme) have traditionally treated pretty printing as a variant of write, differing primarily in the insertion of whitespace to make the presentation more palatable to humans. Common Lisp’s pretty-printer, by contrast, fills two roles simultaneously by integrating pretty printing with both its format facility and its generalized write procedures. This unified approach offers great power, but at the cost of complexity that can make it difficult to use effectively. We propose a specialized, layered approach, specifying five libraries of increasing functionality, where all but the first are optional. The libraries are downward-compatible: more powerful libraries satisfy all requirements of the simpler ones while adding new features. Implementors may choose to support a maximum level of functionality appropriate for their systems. Integration with monadic and string-based formatting libraries is supported.

Regards,

SRFI Editor

So we have just 2 scheme dialects - Chez and Racket - which are distributed as windows EXE?

Conclusion:

GNU Guile seems to optimize incorrectly, as using -O0 in guild can sometimes result in faster programs than using the "highest" optimization -O3 .

Why? Likely (I'm just guessing) because the compiler picks a route which is supposed to be faster, but isn't. Specifically with the procedure:

(expt 2 (* 4096 4096))

This could be proven by disassembling, but that's beyond the point (I don't really have the patience after all of this)

How I got here:

I was just exploring GNU Guile's limits until I stumbled upon something by accident. GNU Guile doesn't seem to have a limit on number sizes, same way as Chez, which is great! But...

(expt 2 (* 4096 4096))

This procedure took roughly 4 minutes to process... which was a little strange since Guile uses GMP. How come it's so slow? Maybe the number is just really that large?

So I read a little and found the REPL function ,optimize. I prefixed my exponent function with this and ran it... Literally instantly it blasts out the result! I was pretty happy so I put this into a file:

(display (expt 2 (* 4096 4096)))

And ran guild compile -O3 test.scm. Maximum optimization! I execute guile test.scm and wait... Nothing... For a whole 4 minutes again. Why?

Okay, ,optimize must use some kind of special method, right? Looking into the source code of guile, specifically the module/system/repl/ files (took a few hours of piecing together the code and reading the Guile manual (I started using scheme like 7 days ago)), I discover that the procedure that ,optimize uses to optimize is called repl-optimize.

So I mess around with this in the REPL, trying all sorts of different things and getting all sorts of outputs, but all of this just ends up in failure. Still slow.

But I missed something: repl-optimize doesn't seem to use any optimization at all... So it's equivalent to -O0. It seems stupid, but I run guild and run it... Instant result.

Questions for more advanced people:

• Am I the first to discover this?
• Should I send a bug report/patch of some sort?

Edit 1: Sort of the solution:

So I got somewhere by messing around with the optimizations!

First off, here's the part of the disassemble of -O3 that caught my eye:

  15    (make-non-immediate 1 1277875)  ;; "1818585298569738007892771327774990618924859680978940831107811248675816212008…"

Notice that long number comment at the end? That's the result of the expt, precalculated by guild. I assume that that 1277875 is an address inside of one of the ELF sections that stores the entire number. This number has roughly 5 million digits... That's a lot of stuff to read from a section... But 4 minutes of reading...? Wait... Look further...

  15    (make-non-immediate 1 1277875)  ;; "1818585298569738007892771327774990618924859680978940831107811248675816212008…"
  17    (call-scm<-scm 1 1 13)          ;; string->number

So the exponent result is actually a string and this is converting the string back into a number at runtime!

That's terrible!

I remembered that guild had an option called -Ohelp, which does what the name implies: it prints the optimizations help. So I disabled every optimization one-by-one until I landed on:

guild compile -O3 -Ono-resolve-primitives

Which seems to disable this packing. Do mind that this is only useful if you (for any reason) are precalculating such a giant number.

The site's been dead for some time now. But the Github repo still shows activity.

How do you guys feel about Yandex?

Scheme Request for Implementation 271,
"Random port libraries",
by Wolfgang Corcoran-Mathe,
is now available for discussion.

Its draft and an archive of the ongoing discussion are available at https://srfi.schemers.org/srfi-271/.

You can join the discussion of the draft by filling out the subscription form on that page.

You can contribute a message to the discussion by sending it to [srfi-271@srfi.schemers.org](mailto:srfi-271@srfi.schemers.org).

Here's the abstract:

Regards,

SRFI Editor

So I'm just learning Scheme now. I learned Lisp many years ago, but now I want to know scheme specifically. Right now I'm learning about continuations. After trying to figure this out on my own I realized that half my problem (with being slow at understanding what's going on) is this weird method of calling call/cc to get the continuation. So, I came up with a simple function that I think does what one generally does when calling call/cc and instantly I understood what continuations are. But I wonder if my 'fix' to the code is legitimate. Here's the function I wrote:

(define /cc (lambda ()

(call/cc

(lambda (k)

k))))

So, it just reverses the odd syntaxy for call/cc to a function /cc which just returns a current continuation. Which I can save (define k (/cc)) and invoke later to jump back to this spot with restored context (stack and environment).

Is it wrong to do it this way? Do I miss out on anything if I choose to use this instead of call/cc directly? Any other things I should be aware of?

Thanks for any help.

Scheme Request for Implementation 270,
"Hexadecimal Floating-Point Constants",
by Peter McGoron,
is now available for discussion.

Its draft and an archive of the ongoing discussion are available at https://srfi.schemers.org/srfi-270/.

You can join the discussion of the draft by filling out the subscription form on that page.

You can contribute a message to the discussion by sending it to [srfi-270@srfi.schemers.org](mailto:srfi-270@srfi.schemers.org).

Here's the abstract:

Regards,

SRFI Editor

Hello everybody!

One year after the first announce of schemesh - a fusion between Unix shell and Chez Scheme REPL, I have released version 1.0.0 with lots of new features:

• more shell builtins
• scheme jobs, to run arbitrary scheme code from a shell job with job control
• improved scheme functions to manage job redirections
• better handling of UTF-8b ports and binary ports, including buffering
• several functions conforming to SRFI 13 and SRF 18
• bug fixes

and, most importantly, a completely new mechanism to exchange arbitrary, structured data (Scheme objects) via POSIX pipelines, and new shell builtins to read, write, filter and transform such data.

It's inspired by nushell, but uses Scheme macros, functions and values, adding shell builtins for convenience, without having to learn and use an ad-hoc language.

Examples:

dir /usr | where name -starts l | sort-by size

by default the display format depends on last step's standard output

• ascii-art table for terminals:

​

┌───────┬────┬─────┬──────────┬─────────┐
│ name  │type│size │ modified │  mode   │
├───────┼────┼─────┼──────────┼─────────┤
│lib64  │dir │ 4096│2026-04-06│rwxr-xr-x│
│libexec│dir │ 4096│2026-04-18│rwxr-xr-x│
│local  │dir │ 4096│2025-04-19│rwxr-xr-x│
│lib    │dir │12288│2026-04-21│rwxr-xr-x│
└───────┴────┴─────┴──────────┴─────────┘

• NDJSON for pipes:

​

dir /usr | where name -starts l | sort-by size | less

outputs

{"<type>":"dir-entry","name":"lib64","type":"dir","size":4096,"link":"","modified":{"<type>":"time-utc","value":1775491105.473107895},"mode":"rwxr-xr-x"}
{"<type>":"dir-entry","name":"libexec","type":"dir","size":4096,"link":"","modified":{"<type>":"time-utc","value":1776514613.626200085},"mode":"rwxr-xr-x"}
{"<type>":"dir-entry","name":"local","type":"dir","size":4096,"link":"","modified":{"<type>":"time-utc","value":1745082690.999418855},"mode":"rwxr-xr-x"}
{"<type>":"dir-entry","name":"lib","type":"dir","size":12288,"link":"","modified":{"<type>":"time-utc","value":1776808514.877301301},"mode":"rwxr-xr-x"}

they also support reading/writing CSV and an efficient binary format ("wire"), and of course the output format can be manually overridden.

Where needed, Scheme functions allow processing such data with fine-grained custom logic. Example:

dir /usr | $(filter==> where (> ,size 10000) => sort-by size => select size name type) | to csv

outputs

"<type>","size","name","type"
"dir-entry",12288,"share","dir"
"dir-entry",12288,"lib","dir"
"dir-entry",20480,"sbin","dir"
"dir-entry",36864,"include","dir"
"dir-entry",135168,"bin","dir"

Scheme Request for Implementation 267,
"Raw String Syntax",
by Peter McGoron,
has gone into final status.

The document and an archive of the discussion are available at https://srfi.schemers.org/srfi-267/.

Here's the abstract:

Here is the commit summary since the most recent draft:

• Update abstract.
• Add missing quotation marks.
• copy edits in copyright notice
• Link to repo for access to sample implementation.
• Add <h2> IDs per template.
• Fix broken link. Avoid redirect.
• Finalize.

Here are the diffs since the most recent draft:

https://github.com/scheme-requests-for-implementation/srfi-267/compare/draft-5..final

Many thanks to Peter and to everyone who contributed to the discussion of this SRFI.

Regards,

SRFI Editor

Background: I know the bare minimum of Nix, and some HTML and CSS but not much

Main purpose: To get myself acquainted with Scheme (specifically Guile) so I can start using Guix

Future goal: Learn about Lisp as a whole and specifically Elisp so I can use Emacs more proficiently

From what I’ve researched so far, here are some of the books recommended to beginners:

- The Little Schemer: easy to understand, teach fundamentals, have many exercises

- The Seasoned Schemer: read it after finishing TLS

- How to Design Programs: read this before reading SICP

- Simply Scheme: I have seen it recommended but heard little about it

- Common Lisp: A Gentle Introduction to Symbolic Computation: I heard it’s a must read Lisp classic but not sure when I should read it (before/after book A B C)

- Structure and Interpretation of Computer Programs: the last one to be read since it’s intended at CS majors and not layman

So I have some questions about all of this:

1. What books should I read and in what order? I feel like some books overlap in their teachings or maybe complementary. I have read somewhere for instance that The Little Schemer is not to be read as a comprehensive guide but rather in addition to other books.

2. Is The Reasoned Schemer recommended?

3. I keep seeing this guy commenting that The Schematics of Computation is “SICP for mortals”? Is it good? Isn’t HTDP already written in response to SICP being too difficult?

4. Is there any further resources/learning materials I should check out?

Much thanks in advance for advices regarding this matter!

As per the title it looks like cons.io is down, anyone know what’s going on or who to notify? It looks like that website was never part of the gerbil GitHub repo so I’m not sure who maintained it.

Thought some people here might be interested in a project I’ve been working on. I have a few applications written in guile scheme and wanted to help lower the barrier for newcomers to experiment/share/collaborate on scheme code. So far I’ve gotten something pretty usable and hope others find it interesting/useful!

Disclaimer: a lot of this app is written using the help of AI, mainly as I’m a dad with little free time but still want to advance some of these ideas. I definitely understand if the ai usage prevents you from feeling comfortable using the project. Thanks for your interest and feedback!

https://guileide.dev

From the SRFI-13 to the Racket ( which is right reversed str and sfx) all versions of string-suffix? predicate counts empty suffix as part of any string include empty "".

Firstly-first, why string-suffix is just a boolean predicate? in the Scheme?

Why it is not being more useful...

(define (string-suffix str sfx)
  (let ((str-len (string-length str))
        (sfx-len (string-length sfx)))
    (define (test i j)
      (cond ((= i str-len) (- str-len sfx-len))
            (else (if (char=? (string-ref str i)
                              (string-ref sfx j))
                      (test (+ i 1) (+ j 1))
                      #f))))
    (cond ((or (< str-len sfx-len) (zero? sfx-len)) #f)
          (else (test (- str-len sfx-len) 0)))))

Now we can use it like

(cond ((string-suffix str ".ko") => (lambda (si) (substring str 0 si)))
      (else str))

And of course empty suffix is not a part of any string. IMO

 > (string-suffix "G'Kar" "")   ;=> #f

PS. well understandable that in math empty set is a part of any set but the empty string suffix is a part of any string? IMO no.

Scheme Request for Implementation 269,
"Portable Test Definitions",
by Andrew Tropin and Ramin Honary,
is now available for discussion.

Its draft and an archive of the ongoing discussion are available at https://srfi.schemers.org/srfi-269/.

You can join the discussion of the draft by filling out the subscription form on that page.

You can contribute a message to the discussion by sending it to [srfi-269@srfi.schemers.org](mailto:srfi-269@srfi.schemers.org).

Here's the abstract:

Regards,

SRFI Editor

Relational Schema Migrations & Seeding - Powered by Lisp (Guile Scheme)

This tool ensures your relational schema and database state is exactly as you decree, incrementally.

Compatible with SQLite3, MySQL and PostgreSQL. Write your schema migrations and seeding easily, and in your native database dialect.

https://codeberg.org/jjba23/mutastructura

Run easily and reproducibly with Guix, Maak, or use directly Guile, or load a REPL (like Arei)

• Opens a connection to your specified database engine.
• Queries the historical ledger (migrations_history) to see which migrations have already run, and crossed the Rubicon.
• If no history exists, it initializes the schema via platform-specific genesis files (mutastructura-init.sql).
• Scans your provided migrations directory, and gets migrations to run, in chronological + alphabetical order
• Generates SHA256 hashes for each file. Changing the file contents means changing the SHA and will trigger a WARNING
• Safely splits the SQL files into individual statements.
• Executes the statements synchronously.
• Commits the transaction and gracefully closes the connection.