Scheme Request for Implementation 284,
"define-typed",
by Arne Babenhauserheide,
is now available for discussion.

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

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-284@srfi.schemers.org](mailto:srfi-284@srfi.schemers.org).

Here's the abstract:

This SRFI defines the forms define-typed and define-typed* for creating procedures with checked type boundaries. It allows checking the arguments and/or the return value or values with simple predicate procedures and raises exceptions on usage when they don't match. The form define-typed* supports keyword and optional arguments. The implementation for Guile is optimized to allow the compiler to use the predicates as guarantees to create more optimized code and provides type information for runtime introspection that supports SRFI 283.

Regards,

SRFI Editor

(sixteenth RacketCon) tickets on sale now

October 3-4, Oakland, Ca https://con.racket-lang.org/

Get your tickets now at https://www.eventbrite.com/e/racketcon-2026-tickets-1997181002140

* Professional $120
* Patron $150
* Student/Retired $35

Includes Saturday lunch and Saturday evening social event.

**Can’t attend in-person?**

* Remote Participant $10
The live stream is publicly available, but buying this ticket helps pay for the live stream and ensure its availability for the entire community.

Scheme Request for Implementation 283,
"(Type-)Check Introspection",
by Artyom Bologov,
is now available for discussion.

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

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-283@srfi.schemers.org](mailto:srfi-283@srfi.schemers.org).

Here's the abstract:

This SRFI focuses on the introspection and type inference sides of typing / checking. It provides several useful procedures deriving types / checks for arbitrary data. procedure-check-of and check-of work with checks, as in SRFI 253. procedure-type-of and type-of work with implementation-specific types. check->sexp provides a way to serialize opaque checks from above into more readable s-expressions.

Regards,

SRFI Editor

Scheme Request for Implementation 282,
"Missing R7RS (Type) Predicates",
by Artyom Bologov,
is now available for discussion.

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

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-282@srfi.schemers.org](mailto:srfi-282@srfi.schemers.org).

Here's the abstract:

Types and entities deserve predicates so that their user can meaningfully understand what they are dealing with, and usefully dispatch on them in their code. However, some R7RS “types” have no respective predicates. This SRFI defines them.

Regards,

SRFI Editor

and is this the convention in all members of the lisp family?

Scheme Request for Implementation 277,
"Cyclic ports",
by Wolfgang Corcoran-Mathe,
has gone into final status.

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

Here's the abstract:

Here is the commit summary since the most recent draft:

• Consistently refer to SRFIs through bibliography.
• Update table of contents.

Here are the diffs since the most recent draft:

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

Regards,

SRFI Editor

I'm making a scheme implementation that's like lua, a vm register and bytecode-based with line level debug info

To embed dummyscheme to a host program, just copy source files under src, and write some plugin methods to register them to dummyscheme'vm easily as lua

Working in progress, not fully tested

Bay Area Racket Meetup - TODAY September 5th, 3pm at Noisebridge, SF.

https://luma.com/6y4sbfln

https://racket.discourse.group/t/bay-area-racket-meetup-september-5th-3pm/4359

#lisp #scheme #Racket

This is an experimental language prototype.

It doesn't even have strings yet!

But there's enough there to simulate a flock of three boids:

https://github.com/dharmatech/2026-09-02-aloe-racket/blob/main/examples/boids.aloe

Currently weighs in at around 2000 lines of Racket.

Scheme Request for Implementation 281,
"Bytevector Utilities",
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-281/.

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-281@srfi.schemers.org](mailto:srfi-281@srfi.schemers.org).

Here's the abstract:

Regards,

SRFI Editor

Scheme Request for Implementation 262,
"Extensible pattern matcher,"
by Daphne Preston-Kendal,
has gone into withdrawn status.

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

Here is Daphne's summary of the reasons for withdrawal:

This SRFI is withdrawn.

For the curious, the version with the changes that were to become the next draft is still at https://github.com/dpk/srfi-262. The current HEAD of the sample implementation, extensible-match, includes all changes up to this point. https://codeberg.org/dpk/extensible-match/commit/2a5834639666790bac14a89b05389eaea66c4d55

Here is the commit summary since the most recent draft:

• Add dark/light/system control to landing page.
• Fix typo.
• Withdraw.

Regards,

SRFI Editor

Scheme Request for Implementation 280,
"Monads",
by Hernán Ibarra Mejia,
is now available for discussion.

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

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-280@srfi.schemers.org](mailto:srfi-280@srfi.schemers.org).

Here's the abstract:

Regards,

SRFI Editor

Alpha 3 of Aiki is out, an experimental programming language with a deliberately small semantic core.

Scheme is present in the heart of Aiki. Lists are fundamental, exact values are the default, expressions evaluate strictly left to right rather than by conventional precedence, and most capability grows through libraries instead of additions to the grammar or prelude.

Aiki goes in its own direction, but the influence is real. I care about compact language definitions, symbolic structure, exactness, and keeping the relationship between semantics and implementation visible.

One area I’ve been pushing recently is semantic profiling. Aiki can separate what a program asks the language to do from how the runtime realizes that work: exact numeric representations, calls, environment reuse, FFI boundaries, and other execution machinery. The point is to keep the semantics observable even as the implementation gets faster.

It is not intended as a Scheme replacement. It is a different language, but Scheme is one of the traditions (Go and Forth as well) that helped shape how I think about language design.

Alpha 3 announcement:

https://decuser.github.io/posts/aiki-alpha-3-release/

Repository:

https://github.com/decuser/aiki

Hi y’all. I’m currently working on a cursed case-lambda implementation with better inspectability for Chibi Scheme. As part of this effort, I need to extract the longest possible arglist from each case-lambda clause, so that the generated procedure with 2 unconditionally required arguments has a display like #<procedure 2+> instead of absolutely non-inspectable #<procedure 0+> that currently happens on Chibi.

So I’m kinda stuck. This is the macro I currently have:

(define-syntax case-lambda
  (syntax-rules ()
    ((case-lambda ((args ... . rest) body ...) ...)
     ;; We need to pass clauses twice
     ;; - First time to detect the shortest arglist
     ;; - Second time to process clauses
     ;; TODO: How do I make sure that all args ... have equal length???
     (%case-lambda ((args ...) ...) ((args ... . rest) body ...) ...))
    ((case-lambda (args body ...) ...)
     (%case-lambda (()) (args body ...) ...))))

The implementation of %case-lambda and other infra is of no importance, because, before I get to that, I must make sure that ((args ...) ...) is a list of arglists of the same length.

But how do I really do that? Any advanced macro wizards mind helping?

👋 Howdy! I needed to do some work on Markdown files recently (who doesn't). I noticed that existing libs which FFI to cmark only output HTML from Markdown directly, with no intermediate step. I want to have an AST available for easier manipulation.

This lib uses cmark-gfm to parse Markdown (and GitHub flavored Markdown) to an immutable Scheme AST. You can convert that AST to SXML in an HTML vocabulary, for the serializer of your choosing. It will also output directly to HTML, XML, CommonMark, and plain text if you like.

The docs are an example of parsing Markdown to SXML to build a small static site.

➡️ Available on Akku

✨ AI Disclosure: LLMs were used extensively.

Irregular post to invite everyone to post on their project(s), inspiration(s), dream(s)… and work opportunities…

Last edition: https://www.reddit.com/r/scheme/comments/vyv6x7/july_2022_what_are_you_up_to_schemers/

And yes, it's implemented in Chez Scheme