Scheme 2026 – Preliminary Table of Contents

27th ACM SIGPLAN International Workshop on Scheme and Functional Programming (Scheme 2026)

Frontmatter

Keynote and Invited Talk

Rhombus: The Non-shrubbery Parts (Keynote)
Matthew Flatt
(University of Utah, USA)
Rhombus is a new language that provides Racket-style extensibility with conventional (infix) notation. This talk is is not about that notation; it's about many other design choices in Rhombus that that are different than Scheme and Racket. We'll look at Rhombus's pervasive pattern matching, generalized repetitions, Lisp-N binding, lists as RRB trees, and mixture of static and dynamic hierarchical binding.

Article Search Article: icfpws26schememain-key1-p doi:10.1145/3830440.3839164

The R7RS-Large Roadmap (Invited Talk)
Peter McGoron
(Georgia Institute of Technology, USA)
The R7RS-Large is an extension to the R7RS designed to address the practical needs of mainstream software development. It is organized into three volumes: Foundations for non-portable modifications to the R7RS such as the syntax-case system, Batteries for libraries that can be built on top of the Foundations such as hash tables, and Environments for implementation-specific libraries such as I/O facilities. The Working Group has made great progress in specifying the R7RS-Large over the past year. I will present the new features we have added, a roadmap for features we plan to add, and challenges along the way that we will have to solve.

Article Search Article: icfpws26schememain-key2-p doi:10.1145/3830440.3839165

Papers

Regions as Continuation Marks
Paulette Koronkevich and William J. Bowman
(University of British Columbia, Canada)
Region-based memory management started as a compiler pass to optimize Standard ML programs. Garbage collection was expensive, manual memory management was unsafe, and so instead one infers a stack of memory regions to enable the compiler to insert explicit memory allocation and deallocation instructions. The result of region inference is a ML program with lexically-scoped regions. Unfortunately, the stack-based region inference interferes with the correct behaviour of tail recursion: that tail recursion must run in constant space, and much work was required to correct their behaviour in practice.
We show a formal connection between these lexical regions and continuation marks, which elucidates the behaviour of regions with respect to tail calls, and provide insights into possible implementation techniques and new semantics. Continuation marks enable placing a value on the dynamic program frame, and were designed and implemented to behave correctly with respect to tail recursion. We provide a translation from regions to continuation marks and theorize what this connection could entail for both languages with region-based memory management and our favourite Schemes (and Racket) with continuation marks.

Article Search Article: icfpws26schememain-p2-p doi:10.1145/3830440.3832303

An Incremental Approach to JIT Construction
Shaurya Raswan, Mark Barbone, Nico Lehmann, and Joe Gibbs Politz
(University of California at San Diego, USA; Cornell University, USA; University of Chile, Chile)
Just-in-time (JIT) compilation has become a common tool for language runtimes. JIT compilers have a reputation for being complex, leaving a pedagogical gap between foundational Ahead-of-Time (AOT) concepts and dynamic code generation. This paper presents an incremental, classroom-scale approach to building a JIT compiler in manageable steps. By contrasting an AOT and a JIT backend, we expose core dynamic concerns, including executable buffers, persistent interactive state, mutation, and runtime type optimizations. The result is a minimal yet realistic educational JIT that successfully supports a Read-Eval-Print Loop (REPL) and a first-call specialization mechanism.

Article Search Article: icfpws26schememain-p3-p doi:10.1145/3830440.3832304

An Array-Oriented Language via the Design Recipe
Martin Scheele and Stephen Chang
(University of Massachusetts at Boston, USA)
We present a new “intertwined” data definition example, the multidimensional array, for How to Design Programs (HtDP). The example has important real-world relevance in many areas of modern computing and thus appeals to a diverse variety of students, yet is straightforward enough to use in lectures and assignments. Best of all, functions dealing with this kind of data can be incorporated into a full programming language, and thus our example complements prior ones and enhances existing ideas. This paper describes our ideas and also presents a first-hand student experience of how they are amenable to and motivated the lessons of HtDP.

Article Search Article: icfpws26schememain-p4-p doi:10.1145/3830440.3832305

Using the Design Recipe in Theory of Computation
Martin Scheele and Stephen Chang
(University of Massachusetts at Boston, USA)
It is well known that computer science students often strug- gle to understand recursion and theory of computation (ToC) students are no exception. The difference is that ToC stu- dents encounter recursion not while programming, but while writing proofs. Fortunately, educators have already devel- oped many strategies for helping students write recursive programs, with many of the ideas coming from the func- tional programming community. This paper explains how we adapted one of these ideas, that of “Design Recipes” from the “How to Design Programs” textbook, into a technique to help theory of computation students write inductive proofs. With our approach, we have seen improved results over sev- eral semesters. Even better, students leave the course with a deeper understanding of the fundamental ideas and rely less on memorizing opaque rules and copying from tangentially related examples.

Article Search Article: icfpws26schememain-p5-p doi:10.1145/3830440.3832306

proc time: 0.09