Scheme Request for Implementation 289,
"Unordered sets and bags",
by Wolfgang Corcoran-Mathe (text and test suite), Peter McGoron (sample implementation), and John Cowan (author of SRFI 113),
is now available for discussion.

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

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 [email protected].

Here's the abstract:

Sets and bags (also known as multisets) are unordered collections that contain only objects of a type given by a collection's SRFI 128 comparator. Every element of a set is unique (in the sense of the set's comparator), but bags can contain any number of duplicate elements. This SRFI is a revision of SRFI 113 that fixes several infelicities and is more consistent with related SRFIs.

Regards,

SRFI Editor

Hey y'all 🙋‍♂️

I'm not the owner of the project.
Just been following it.

In Schevana V0, everything was drawn by Cairo.
Now, in V1, everything is drawn via GPU...
Shaders are written in Scheme and compiled to GPU code.

There's a now a Boids 3D demo which can easily handle up to 5000 birds.
In that demo, everything runs on the GPU (calculations and graphics).

Boids 2D has also been updated to be far more efficient.
It can also handle up to 5000 birds.

I tested it on Ubuntu 26.04. Runs great there.

Teeny Scheme is a fork of TinySCHEME focusing on bringing the code and implementation up to speed with both modern C and R(5|7)RS standard. As of Hairspray Queen release, it supports most of (scheme *) libraries and 27 SRFIs while staying under 6KLoC.

Give it some love!

Hey y'all 🙋‍♂️

I'm not the owner of this project. Just sharing.

https://github.com/paveluv/Schevana

A Lisp Machine-style desktop that lives inside one host window and is written entirely in Chez Scheme. Every window, color, key binding, status-bar segment and running process is a live Scheme value. You can inspect it, redefine it and break it from a REPL that runs inside the world it changes.

Scheme Request for Implementation 272,
"Pretty Printing",
by Sergei Egorov,
has gone into final status.

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

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.

Here is the commit summary since the most recent draft:

• Add SPDX license metadata.

• Update table of contents.

• Link to sample implementations (Git repo).

• copy edit

• Finalize. Add See-also link to SRFI 166.

Here are the diffs since the most recent draft:

https://github.com/scheme-requests-for-implementation/srfi-272/compare/draft-4..final

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

Regards,

SRFI Editor

Scheme Request for Implementation 279,
"In(tro)spection Protocol",
by Artyom Bologov,
has gone into final status.

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

Here's the abstract:

Interactive REPL-driven systems (that most Schemes are) need a way to get detailed information on a given piece of data. Inspectors, as these are conventionally called. This SRFI defines a basic protocol for inspectors, consisting of three procedures: inspect-properties, inspect-property, and inspect-describe. Some suggestions for standard and popular types' inspection are also provided.

Here is the commit summary since the most recent draft:

• Drop unused license.

• copy edits

• Drop trailing whitespace.

• Finalize.

Here are the diffs since the most recent draft:

https://github.com/scheme-requests-for-implementation/srfi-279/compare/draft-3..final

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

Regards,

SRFI Editor

Scheme Request for Implementation 242,
"The CFG Language,"
by Marc Nieper-Wißkirchen,
has gone into withdrawn status.

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

It had been finalized in 2023, but has been withdrawn in favor of SRFI 265, also named The CFG Language, also by Marc.

Here is the commit summary since finalization:

• Add dark/light/system control to landing page.

• Withdraw in favor of SRFI 265.

Regards,

SRFI Editor

Scheme Request for Implementation 265,
"The CFG Language",
by Marc Nieper-Wißkirchen,
has gone into final status.

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

Here's the abstract:

This SRFI defines a language to describe control-flow graphs (CFGs) suitable for formulating iterative and recursive algorithms. Using the notion of a CFG term, this language can be seamlessly embedded in the Scheme language. Complex CFG terms can be composed from simple CFG terms.

The language described in this SRFI is not meant to be directly used in programs but by library authors to build abstractions like loop facilities on top of it.

Here is the commit summary since the most recent draft:

• Fix errors reported by Zhu Zihao.

• Finalize.

Here are the diffs since the most recent draft:

https://github.com/scheme-requests-for-implementation/srfi-265/compare/draft-2..final

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

Regards,

SRFI Editor

Scheme Request for Implementation 288,
"Compound Conditions",
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-288/.

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 [email protected].

Here's the abstract:

A condition object system is introduced that attempts to be implementable in and interoperable with many implementation's condition systems, including the condition system of the R⁶RS. The condition system includes compound conditions, but does not include subtyping of conditions. Simple conditions can be any implementation-defined value, and are also objects that can be made with the interface in this SRFI. An implementation may add other features, such as introspection and serialization.

Regards,

SRFI Editor

I put together a bibliography with a in browser search engine for Scheme and related topics, but not about tail call modulo cons!

If you want to be in, doi or not, please comment.

https://hyper.dev/scheme/

I'm try to remember a scheme book I read sometime between 1999 and 2003 (from a Johns Hopkins summer class for high school students). I lent it to a friend I've since lost touch with... Some distinctives I remember (though I may be conflating two books):

• It built up from basic evaluation to a kind of OOP (objects that receive messages and set! internal state declared using let-expressions)

• It used that OOP to implement a learning-from-win/loss approach to playing a game like Connect 4.

• It used black vs red typesetting to distinguish quoting (IIRC)

• It built up number objects by counting nesting parentheses, and I think did the divide-and-conquer exponentiation algorithm x^(2y) = x^y * x^y

• Functions were always written out very explicitly, like (define f (lambda (...) (let (...) ....

It was definitely not Little Schemer, which has a very different style.

The fact that I still remember those details decades later should be saying something about its quality. Any ideas?

Hi y’all! I’m working on Teeny Scheme, a modernization fork of TinyScheme, and the thing most lacking for R7RS (and R5RS) support is an implementation of syntax-rules. Do y’all maybe know where I can find some copyright-sane syntax-rules implementation in mostly-R5RS Scheme?

Scheme Request for Implementation 278,
"Supplemental Numerics",
by Peter McGoron,
has gone into final status.

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

Here's the abstract:

This SRFI defines procedures on Scheme numbers that aim to improve the portability and usefulness of Scheme arithmetic. These procedures include predicates with extended domains, hyperbolic and inverse hyperbolic functions, the R6RS numeric tower, and additional procedures for rounding. Also included are recommendations and justifications for mixed inexact/exact arithmetic to make complex number arithmetic more predictable.

Here is the commit summary since the most recent draft:

• Copyedits by Zhu Zihao.

• Update math.png.

• Add SPDX license metadata.

• copy edits

• Use MathML to beautify more math expressions.

• Finalize.

Here are the diffs since the most recent draft:

https://github.com/scheme-requests-for-implementation/srfi-278/compare/draft-6..final

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

Regards,

SRFI Editor

Scheme Request for Implementation 287,
"Graphs",
by Duncan Guthrie,
is now available for discussion.

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

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 [email protected].

Here's the abstract:

This SRFI proposes a programming interface for working with graphs, based on Martin Erwig's functional graph library design. The FGL design takes a rather different view of graphs from most graph presentations, in that the data structures are persistent, which is a good fit for Scheme. The interface is generic to any node and edge label data-type, as long as a SRFI 128 comparator can be specified.

Regards,

SRFI Editor

Scheme Request for Implementation 275,
"URIs, IRIs, and basic paths",
by Duncan Guthrie,
has gone into final status.

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

Here's the abstract:

This SRFI proposes a programming interface for working with RFC 3986 universal resource identifiers (URIs), as well as RFC 3987's generalization to internationalized resource identifiers (IRIs). This document defines record types, normalization procedures, and conversion between URIs and IRIs. The proposal also specifies a basic programming interface for working with paths in isolation, as this is a pervasive usage of URIs and IRIs. Finally, we contribute a test suite to specify the behaviour of normalization with respect to relative references, which has in the past been a source of divergence between implementations.

Here is the commit summary since the most recent draft:

• Final draft

• Check in sample implemenation prior to finalisation.

• (iri internal) -> (srfi :275 internal)

• Eliminate the (iri internal xxx) namespace

• lib/test -> tests

• Chez-specific test import

• Make the Chez-specific import specific

• copy edits

• Add missing SPDX license metadata.

• Finalize.

• Link to sample implementation in official repo.

Note that these changes were adding the sample implementation to the repo, copy edits, and administrative work.

Here are the diffs since the most recent draft:

https://github.com/scheme-requests-for-implementation/srfi-275/compare/draft-8..final

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

Regards,

SRFI Editor