r6rs | R6RS compliant Scheme interpreter in JavaScript | Interpreter library

The honest answer is probably "no" - there is not a single version of srfi preferred by the community.

But to (kinda) answer my own question, whilst I can't say it's a defacto standard yet, Akku is a package manager and virtual environment management system of Scheme that is miles ahead of any of the alternatives, and actively developed. It's not an individual implementation of srfi, but is a way to install various Scheme packages you need to use through a single interface.

https://akkuscm.org/

It's not quite venv and pip - but it's getting there. I'm amazed this isn't talked about more, I only stumbled upon it some time after my initial search for a tool like this.

You get a single interface to pull packages for both R6RS and R7RS, and a range of Scheme implementations.

There is also Snow, which is currently only supporting R7RS: http://snow-fort.org/

But as Akku mirrors Snow as well as providing R6RS support, it is more comprehensive.

To answer the specifics of the original example - Akku installs chez-srfi by default (on a Chez Scheme system at least) on creation of a new project, but also offers thunderchez as a package. Whether that indicates a preference by the Akku developer's, I'll leave up to the reader to decide.

The original question was about a single defacto srfi implementation for Chez, rather than a more general package manager. In hindsight this misses the point a bit, simply because I didn't think a single package manager (beyond srfi) was a remote possibility.

So for my use at least - Akku, not only provides various implementations of srfi, but also offers a host of other packages, and largely answers my question.

An operation that returned a bytevector's address as an integer would be dangerously unsafe, since the garbage collector might subsequently move the bytevector and place other objects there. Passing a stale address to C code could cause memory corruption.

The docs for Chez Scheme's foreign-procedure say that an argument declared as u8* accepts a bytevector and passes the address of its contents to the foreign function. That's safe, because the FFI and GC cooperate to make sure the object is not moved between taking the address and calling the foreign function --- but see the warning about retaining the pointer in foreign data structures. See also lock-object, which temporarily prevents the GC from moving or reclaiming an object.

In Racket, the _bytes and _pointer foreign types work similarly. There's also a ptr-add operation that combines a pointer-like object with an offset. For example, if bs is a bytestring, then (ptr-add bs 1 _byte) is reliably converted to the address of the second byte of bs, even if the GC moves bs. I don't know if Chez has a similar feature.

It's polar notation for complex numbers @. I've never found documentation for it other than the syntax but I'd guess that is in radians.

(magnitude 2@2) => 2.
(angle 2@2) => 2.

I think top level is different in different implementations. For Racket, call/cc captures continuation up to a single, top-most expression, not the whole program. I think Guile captures up to the whole program. Hence the difference.

You can get Guile's behavior by writing your code in a function:

Chez Scheme does allow for custom reading and writing of most records, including hashtables. Chez Scheme provides a record-writer and record-reader procedure which allow customizing the functions used to write and read records:

http://cisco.github.io/ChezScheme/csug9.5/objects.html#./objects:s176

There are some good examples on that page, but an important detail is that you can specify #f as the writer, the default for new record types, which will use a format capable of being read back by the default reader. This won't work 100% of the time as there are some types which have no serializable representation, like functions.

Once I disable the special printer for eq-hashtables and the special printer for the base hashtables, I can see the default representation:

Your input was incorrect.

The Racket implementation of R⁶RS is not non-compliant in this case. Indeed, if anything, it is obeying the standard more closely: your program as-written is not careful about import phases. The problem is that define-syntax evaluates its right-hand side during expand-time, as noted by section 11.2.2 Syntax definitions:

Binds to the value of , which must evaluate, at macro-expansion time, to a transformer.

Unlike other Scheme standards, R⁶RS takes care to distinguish between phases, since it permits arbitrary programming at compile-time (while other Scheme standards do not). Therefore, section 7.1 Library form specifies how to import libraries at specific phases:

Each specifies a set of bindings to be imported into the library, the levels at which they are to be available, and the local names by which they are to be known. An must be one of the following:

1. Absolutely not. Scheme has several SRFIs for custom types, aka. record types, and with R7RS Red edition it will be SRFI-136, but since you mention R6RS it has records defined in the standard too.

Example using R6RS:

Although it might not be a hygienic macro, i suppose you could use define-syntax like this (in chicken scheme). For chicken scheme the documentation for macros is here. Also this SO question sheds some light on chicken scheme macros. Finally i don't know if this would be an idiomatic way to approach the problem.