\documentclass{beamer}
\usepackage[utf8x]{inputenc}
\usepackage{textgreek}
\usepackage{fancyvrb}
\usepackage[dvipsnames]{xcolor}

%\setbeameroption{hide notes} % Only slides
%\setbeameroption{show only notes} % Only notes
\setbeameroption{show notes on second screen=right} % Both

\newcommand{\rnrs}[1]{R\textsuperscript{#1}RS}

\title{The \rnrs{7}-Large Roadmap}
\author{Peter McGoron}\date{August 29\textsuperscript{th}, 2026}

\begin{document}

\begin{frame}
  \titlepage

%  {\footnotesize\centering CC0 license}

  \note[item]{Hello everyone. I am Peter McGoron, a member of Working
Group 2, which is responsible for writing the \rnrs{7}-Large.}
  \note[item]{This talk
is going to be about the roadmap for the new Report, and what we plan to
include in it, above the original \rnrs{7}.}
  \note[item]{I'd like to make a disclaimer that this roadmap is subject
  to change.}
\end{frame}

\begin{frame}
\frametitle{What is the \rnrs{7}-Large?}

\begin{itemize}
  \item \rnrs{7} was released in 2013
  \item \rnrs{7}-Large is an extension of \rnrs{7}
  \item Intended to address the practical needs of software development
  \item Encompass the \rnrs{6} (as much as we can)
  \item Fix errata and other inconsistencies in the \rnrs{7}
\end{itemize}

\note[item]{So just to review --- what is the \rnrs{7}-Large?}
\note[item]{It is a downwards compatible version of the \rnrs{7}
(the small report), intended to address the practical needs of software
development.}
\note[item]{The \rnrs{7}-Large is intended to encompass
the \rnrs{6} to at least some extent.}
\note[item]{In the process, we will also be collecting and fixing parts
of the \rnrs{7} that have come up after its ratification.}
\end{frame}

\begin{frame}
\frametitle{How is the \rnrs{7}-Large organized?}

\begin{columns}
\begin{column}{0.33\textwidth}
\textbf{Volume I: Foundations}

\only<2->{Things in \rnrs{7}, with extensions not implementable in it.}

\only<5->{This talk: 90\%}
\end{column}
\begin{column}{0.33\textwidth}
\textbf{Volume II: Batteries}

\only<3->{Things implementable in terms of the Foundations (or \rnrs{7}).}

\only<5->{This talk: 5\%}
\end{column}
\begin{column}{0.33\textwidth}
\textbf{Volume III: Environments}

\only<4->{Things specific to the operating environment, such as I/O or network access.}

\only<5->{This talk: 5\%}
\end{column}
\end{columns}

\note[item]<1>{In order to accomplish that, we are going to have a very
large standard. So we split it up into three volumes: the Foundations,
the Batteries, and the Environments.}

\note[item]<2>{The Foundations is, roughly, a superset of the \rnrs{7}.
It contains new features that cannot be implemented portably in
\rnrs{7}, such as \texttt{syntax-case}, and number vectors, along with
some extensions like bitwise operations and a record type system that
benefit a lot from being implemented as primitive.}

\note[item]<3>{The Batteries are libraries that can be implemented on top
of the Foundations, or in many cases, atop \rnrs{7}. These are many
of the libraries that have already been advertised as being in the
\rnrs{7}-Large, such as list utility libraries, hash tables, and sorting
algorithms.}

\note[item]<4>{The Environments are libraries that are optional but strongly
recommended. They allow one to portably interact with the outside environment.
The scope of this volume is file I/O, POSIX APIs, network access, and foreign
function interfaces. This volume is the one that we are the most uncertain
about what will be inside of it, so there is not much concrete I can say
about it at this time.}

\note[item]<5>{This talk is going to focus mostly on the Foundations. This
is because this is where most of the current work is going. I will quickly go
over what is in the Batteries right now, and what we plan to put in
the Environments.  But major work on those will wait until later.}
\end{frame}

\begin{frame}
\frametitle{How is the \rnrs{7}-Large Foundations organized?}

Split into 7 \textit{fascicles}:

\note[item]{Since the Foundations is very large, we have split it
up into seven fascicles, which will eventually be edited together into
a final volume. Each fascicle has a codename that corresponds roughly
to what topics that portion will cover.}

\note[item]{The fascicles cover macros, procedural programming forms,
data types, the error system, the library system, continuations, and
the record type system. I'm going to go through each one and talk about
what's in them, or what we plan to put in each one.}

\begin{itemize}
\item The Macrological Fascicle (macros) {\footnotesize (October 2024)}
\item The Procedural Fascicle (procedural programming) {\footnotesize (May 2026)}
\item The Valued Fascicle (Scheme values)
\item The Erroneous Fascicle (error system)
\item The Bibliothecarial Fascicle (library system)
\item The Flow-Controlling Fascicle (continuations)
\item The Record-Winning Fascicle (record type system)
\end{itemize}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large? --- Macros}

Split into 7 \textit{fascicles}:

\begin{itemize}
\item The Macrological Fascicle (macros) {\footnotesize (October 2024)}
\item \textcolor{bg!85!normal text.fg}{The Procedural Fascicle (procedural programming) {\footnotesize (May 2026)}}
\item \textcolor{bg!85!normal text.fg}{The Valued Fascicle (Scheme values)}
\item \textcolor{bg!85!normal text.fg}{The Erroneous Fascicle (error system)}
\item \textcolor{bg!85!normal text.fg}{The Bibliothecarial Fascicle (library system)}
\item \textcolor{bg!85!normal text.fg}{The Flow-Controlling Fascicle (continuations)}
\item \textcolor{bg!85!normal text.fg}{The Record-Winning Fascicle (record type system)}
\end{itemize}
\note[item]{The first fascicle describes the macro system. Much of it comes
from the \rnrs{6}, with some innovations from Racket. It was released in
October 2024.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large? --- Macros}
\begin{itemize}
\item<1-> Extension of \rnrs{6} (\texttt{syntax-case}, etc)
\item<1-> Combined with \rnrs{7} extensions
\item<2-> Procedural macro system (\texttt{unwrap-syntax}, \texttt{quote-syntax})
\item<3-> Syntax parameters
\item<4-> Identifier properties
\end{itemize}

\note[item]<1>{The macro system of the \rnrs{7}-Large will encompass
all of the \rnrs{6} system. This includes \texttt{syntax-case} and
identifier macros. This will be combined with \rnrs{7} extensions,
such as custom ellipses in transformers.}

\note[item]<2>{One of the criticisms of \texttt{syntax-case} was that
it was pretty complicated for a ``low-level'' macro system. To address
this, the macro system now includes a minimalistic system based off of the
\texttt{unwrap-syntax} procedure and the \texttt{quote-syntax} primitive.
This system is similar to the low-level macro system in the \rnrs{4}
appendix. They allow one to introduce known identifiers and destructure
syntax objects manually.}

\note[item]<3>{Syntax parameters are a feature originally in Racket, where
one can implement a seemingly unhygienic macro in a hygienic
manner, analogous with the dynamic extent of \texttt{parameterize}d
variables.}

\note[item]<4>{Identifier properties are a feature we have adapted from
Chez Scheme, where one can attach expand-time properties to identifiers
that can then be inspected in a macro transformer. This can be used to
define powerful macros like an extensible pattern matcher.}
\end{frame}

\begin{frame}[fragile]
\frametitle{What is in the \rnrs{7}-Large? --- \texttt{unwrap-syntax}}
\begin{verbatim}
(define (scar stx)
    (car (unwrap-syntax stx)))

(define (scdr stx)
    (cdr (unwrap-syntax stx)))

(define (scadr stx)
    (scar (scdr stx)))

(define (scddr stx)
    (scdr (scdr stx)))

(identifier? (scadr #'(x y))) => #t
\end{verbatim}

\note[item]<1>{Here is an example of the procedural macro system, which
is similar to the one described in the appendix of the \rnrs{4}.}

\note[item]<1>{A syntax object is a wrapped syntax object, an identifier,
a pair containing syntax objects, or a vector containing syntax objects.
Hence, in order to access the underlying object in the syntax object,
one has to use \texttt{unwrap-syntax}.}

\note[item]<1>{The procedure \texttt{unwrap-syntax}
will destructure the syntax object one level while propagating the syntactic
context downwards. So a wrapped syntax object pair will be turned into
a pair with wrapped syntax objects as its car and cdr. Syntactic context
propagation is lazy: a syntax object representing a list may be an improper
list which is converted into a proper list by multiple invocations of
\texttt{unwrap-syntax}.}

\note[item]<2>{You can see this in the definitions of \texttt{scar}
and \texttt{scdr}. Each procedure must call \texttt{unwrap-syntax} on the
input syntax object in order to get the underlying pair, and then call
the corresponding list accessor. Note that \texttt{unwrap-syntax} will
not do anything to an already unwrapped syntax object: an unwrapped pair
is returned unchanged. With these procedures, we can then build up
analogous list accessors, such as \texttt{scadr}, as you can see from
the evaluation example below.}
\end{frame}

\begin{frame}[fragile]
\frametitle{What is in the \rnrs{7}-Large? --- \texttt{unwrap-syntax}}
\begin{verbatim}
(define (smap f stx)
    (if (null? (unwrap-syntax stx))
        '()
        (cons (f (scar stx))
              (smap f (scdr stx)))))

(define-syntax let
  (lambda (stx)
    `((,(quote-syntax lambda)
       ,(smap scar (scadr stx))
       . ,(scddr stx))
      ,@(smap scadr (scadr stx)))))
\end{verbatim}

\note[item]{Here is an example of \texttt{let} in a procedural style. We
first need to define the helper function \texttt{smap}, which
turns out to be very similar to regular \texttt{map}. The returned
object is still a syntax object, even when it is composed of lists,
because a pair containing syntax objects is still a syntax object.}

\note[item]{The \texttt{let} macro itself is written in a style
deliberately similar to how one would write such a macro in a system like
Common Lisp's \texttt{defmacro} or the explicit renaming macro system.}

\note[item]{The \texttt{quote-syntax} form, which is similar to the
\texttt{syntax} form in the \rnrs{4}, inserts an identifier that resolves
to the binding of the identifier where the macro is written. In this example,
it inserts an identifier that resolves to the \texttt{lambda} available
to the definition of \texttt{let}.}
\end{frame}

\begin{frame}[fragile]
\frametitle{What is in the \rnrs{7}-Large? --- Syntax parameters}
\begin{verbatim}
(define-syntax-parameter it
  (erroneous-syntax "only usable inside of aif"))

(define-syntax aif
  (syntax-rules ()
    ((_ condition on-true on-false)
     (let ((tmp condition))
       (syntax-parameterize
           ((it (identifier-syntax
                  (_ tmp)
                  ((set! _ value)
                   (set! tmp value)))))
         (if tmp on-true on-false))))))
(aif 10 (* 10 it) 20) => 100
\end{verbatim}

(Barzilay, Culpepper, and Flatt. ``Keeping it Clean with Syntax Parameters.'' (2011))

\note[item]{The next major feature is syntax parameters, which originate
in Racket. Syntax parameters allow one to write seemingly unhygienic
macros in a hygienic way. A common unhygienic macro is anaphoric \texttt{if},
which is implemented with syntax parameters here.}
\note[item]{The macro uses \texttt{it} as a keyword.
The \texttt{erroneous-syntax} macro is a transformer that
raises a syntax error when the identifier is used if it is not parameterized.}

\note[item]{This macro also shows off the \texttt{identifier-syntax}
form from \rnrs{6} which is included in the \rnrs{7}-Large, which allows
us to hide the \texttt{tmp} variable behind the syntax parameter.}

\note[item]{An evaluation sample is shown below, where you can see that
the value of the test expression is bound to \texttt{it}.}
\end{frame}

\begin{frame}[fragile]
\frametitle{What is in the \rnrs{7}-Large? --- Identifier properties}
\small
\begin{verbatim}
(define-pattern-syntax cons
  (syntax-rules ()
    ((_ car-pat cdr-pat)
     (? pair?
        (=> car car-pat)
        (=> cdr cdr-pat)))))

(define (fold proc seed ls)
    (let f ((acc seed) (ls ls))
      (match ls
        ((cons h t) (f (proc h acc) t))
        ('() acc)
        (_ (assertion-violation 'fold
                                "not a list"
                                ls))))))
\end{verbatim}

(Preston-Kendal. ``SRFI 262: Extensible pattern matcher.'' (2025) (draft))

\note[item]{Identifier properties are another new feature that allow for
the programmer to bind arbitrary data to an identifier. This allows
for macros to communicate with each other, and allows for user extension
of macros. The example in this slide is from Daphne Preston-Kendal's
extensible pattern matcher.  One can extend the pattern matcher by
adding new patterns to it, in this case the \texttt{cons} pattern. After
defining the new pattern syntax, one can then use it in the \texttt{match}
macro below.}

\note[item]{The \texttt{define-pattern-syntax} form
is implemented with identifier properties. The extensible pattern matcher
is based off of the one in Racket.}

\note[item]{Beyond this example, one can implement the \texttt{syntax-case}
pattern matcher using identifier properties. Generally, identifier properties
are very useful for any form where
identifiers inside of it are given special meanings in other macros.}
\end{frame}
\begin{frame}
\frametitle{What is in the \rnrs{7}-Large?}

Split into 7 \textit{fascicles}:

\begin{itemize}
\item \textcolor{bg!85!normal text.fg}{The Macrological Fascicle (macros) {\footnotesize (October 2024)}}
\item {The Procedural Fascicle (procedural programming) {\footnotesize (May 2026)}}
\item \textcolor{bg!85!normal text.fg}{The Valued Fascicle (Scheme values)}
\item \textcolor{bg!85!normal text.fg}{The Erroneous Fascicle (error system)}
\item \textcolor{bg!85!normal text.fg}{The Bibliothecarial Fascicle (library system)}
\item \textcolor{bg!85!normal text.fg}{The Flow-Controlling Fascicle (continuations)}
\item \textcolor{bg!85!normal text.fg}{The Record-Winning Fascicle (record type system)}
\end{itemize}

\note[item]{Moving on to the second fascicle,
which involves procedural programming forms like \texttt{lambda}, \texttt{if},
and \texttt{cond}. It was released in May of this year.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large? --- Procedure forms}
\begin{itemize}
\item<1-> Mixing definitions and expressions
\item<2-> Aliases (\texttt{define-alias})
\item<3-> More multiple-values forms (\texttt{letrec*-values}, \texttt{set!-values})
\item<4-> Helpers for higher-order procedures (define higher-order lambda
          and anonymous recursive expressions)
\item<5-> and more
\end{itemize}

\note[item]<1>{The most important feature of this fascicle is the ability
to mix definitions and expressions in the bodies, like the body of a
\texttt{lambda}.}

\note[item]<2>{There is now a way to define an alias to an identifier
with the \texttt{define-alias} form.}

\note[item]<3>{More multiple values forms have been added to make all of
the binding forms have a consistent single value and multiple value form.}

\note[item]<4>{Some forms that make higher-order procedures easier to
write, such as higher-order definitions and anonymous recursive
expressions.}

\note[item]<5>{And some other changes which are too minor to have their
own slide.}
\end{frame}

\begin{frame}[fragile]
\frametitle{What is in the \rnrs{7}-Large? --- Mixing definitions and expressions}
\begin{columns}
\scriptsize
\begin{column}{0.45\textwidth}
\begin{verbatim}
(define (map f lst)
  (unless (list? lst)
    (error 'map "not a list" lst))
  (define (map* lst acc)
    (if (null? lst)
        (reverse acc)
        (map* (cdr lst)
              (cons (f (car lst))
                    acc))))
  (map* lst '()))
\end{verbatim}
\end{column}
\begin{column}{0.55\textwidth}
Acts as-if a sequence of \texttt{define}(\texttt{-values})s is turned into
a \texttt{letrec*}(\texttt{-values}), and the subsequent expressions and
definitions are in the body of that \texttt{letrec*}(\texttt{-values}).
\end{column}
\end{columns}

\note[item]{So let's start at mixing definitions and expressions. Here is
a definition that is now valid in \rnrs{7}-Large. The \texttt{unless}
statement checks the validity of the \texttt{lst} argument before
going into the actual loop for \texttt{map}.}

\note[item]{In \rnrs{6} and \rnrs{7}, this is invalid, because the
\texttt{define} comes after an expression. The \rnrs{7}-Large relaxes
this, by grouping every sequence of definitions into the equivalent
of a \texttt{letrec*}.}

\end{frame}

\begin{frame}[fragile]
\frametitle{What is in the \rnrs{7}-Large? --- Mixing definitions and expressions}
\begin{columns}
\scriptsize
\begin{column}{0.45\textwidth}
\begin{verbatim}
(define (map f lst)
  (unless (list? lst)
    (error 'map "not a list" lst))
  (define (map* lst acc)
    (if (null? lst)
        (reverse acc)
        (map* (cdr lst)
              (cons (f (car lst))
                    acc))))
  (map* lst '()))
\end{verbatim}
\end{column}
\begin{column}{0.55\textwidth}
A valid translation into binding expressions:
\begin{verbatim}
(define (map f lst)
  (unless (list? lst)
    (error 'map "not a list" lst))
  (letrec*
      ((map*
        (lambda (lst acc)
          (if (null? lst)
              (reverse acc)
              (map* (cdr lst)
                    (cons (f (car lst))
                          acc))))))
    (map* lst '())))
\end{verbatim}
\end{column}
\end{columns}

\note[item]{Here is an example of a conforming transformation of the
left hand side expression. Note that the \texttt{unless} statement is
not evaluated as a binding in the \texttt{letrec*}, like \texttt{map*}
is. This means that non-definition forms are allowed to return multiple
times.}
\end{frame}

\begin{frame}[fragile]
\frametitle{What is in the \rnrs{7}-Large? --- Mixing definitions and expressions}
\begin{columns}
\scriptsize
\begin{column}{0.35\textwidth}
An example of an invalid definition:
\begin{Verbatim}[commandchars=\\\{\}]
(define (example)
  (define-values (x y)
    (do-something))
  (define (h arg)
    (map \textcolor{BurntOrange}{z} arg))
  (do-something-else! x y)
  (define z
    (do-more-stuff x))
  (h (z y)))
\end{Verbatim}
\end{column}
\begin{column}{0.65\textwidth}
Translation:
\begin{Verbatim}[commandchars=\\\{\}]
(define (example)
  (letrec*-values (((x y) (do-something))
                   ((h) (lambda (arg)
                          (map \textcolor{BurntOrange}{z} arg))))
    (do-something-else! x y)
    (letrec*-values (((z) (do-more-stuff x)))
      (h (z y)))))
\end{Verbatim}
\end{column}
\end{columns}

\textbf{Forward references are not allowed.}

\note[item]{To illustrate the consequences of this sort of transformation,
here is an artificial example. The left hand side is invalid under the
transformation in the previous slide. This is because of the forward reference of \texttt{z}
in the definition of \texttt{h}. The first two definition forms are
separated from the definition of \texttt{z} by the expression
\texttt{do-something-else!}, and hence they get put in different
recursive binding forms.}
\end{frame}

\begin{frame}[fragile]
\frametitle{What is in the \rnrs{7}-Large? --- Mixing definitions and expressions}
\begin{columns}
\scriptsize
\begin{column}{0.35\textwidth}
An example of an invalid definition:
\begin{Verbatim}[commandchars=\\\{\}]
(define (example)
  (define-values (x y)
    (do-something))
  (define (h arg)
    (map \textcolor{BurntOrange}{z} arg))
  (do-something-else! x y)
  (define z
    (do-more-stuff x))
  (h (z y)))
\end{Verbatim}
\end{column}
\begin{column}{0.65\textwidth}
An allowable transformation method that allows the previous definition:
\begin{Verbatim}[commandchars=\\\{\}]
(define (example)
  (let ((x #f) (y #f) (h #f) (z #f))
    (set!-values (x y) (do-something))
    (set! h (lambda (arg)
              (map \textcolor{BurntOrange}{z} arg)))
    (do-something-else! x y)
    (set! z (do-more-stuff x))
    (h (z y))))
\end{Verbatim}
\end{column}
\end{columns}
\textbf{Forward references are not portable.}

\note[item]{Intuitively, a forward reference inside of a
\texttt{lambda} should work, just like it does at
the REPL.  The fascicle is written such that an implementation
can support these forward declarations. Here is an example of a
transformation that allows the forward declaration.  It is a direct
translation into a \texttt{let}-and-\texttt{set!} that still allows for
\texttt{do-something-else!} to return multiple times.}

\note[item]{This is allowed, but not required, because this sort of
transformation may be difficult for implementations to optimize.
This transformation does not allow for an implementation to
``fix \texttt{letrec}'' as easily.}
\end{frame}

\begin{frame}[fragile]
\frametitle{What is in the \rnrs{7}-Large? --- \texttt{define-alias}}
\begin{verbatim}
(define-alias default else)
(cond
  ((string? 1) 'foo)
  (default 'bar)) ; => bar

(define-syntax bad-default
  (identifier-syntax else))
(cond
  ((string? 1) 'foo)
  (bad-default 'bar)) ; => error!
\end{verbatim}

\note[item]{The new \texttt{define-alias} form creates an identifier that is
equivalent as a free identifier to another identifier. This means that
the identifier points to the same syntactic binding, and is not merely
a new binding that takes the old bindings value, or a new macro binding
that expands to the other identifier.}

\note[item]{As you can see in the first two statements on the left,
when \texttt{default} is aliased to \texttt{else}, \texttt{default}
behaves like \texttt{else} in a \texttt{cond} clause.}

\note[item]{However, trying to do the same thing with an identifier
macro fails, because the syntax transformer for the \texttt{cond}
clause does not interpret \texttt{bad-default} as \texttt{else}
until after it has been expanded, and an error results as the
auxiliary syntax keyword \texttt{else} is being used as a variable.}
\end{frame}

%\begin{frame}[fragile]
%\frametitle{What is in the \rnrs{7}-Large --- Multiple value forms}
%\begin{verbatim}
%(let ((x #f) (y #f))
%  (set!-values (x . y) (values 'a 'b))
%  (list x y))    ; => (a (b))
%
%(letrec-values
%    (((even? odd?)
%      (values (lambda (n)
%                (or (zero? n)
%                    (odd? (- n 1))))
%              (lambda (n)
%                (and (not (zero? n))
%                     (even? (- n 1)))))))
%  (even? 12))    ; => #t
%\end{verbatim}
%
%\note[item]{The \rnrs{7}-Large also introduces some new multiple value
%binding forms to round out the current \texttt{define-values} and
%\texttt{let-values} family.}
%
%\note[item]{The forms act more-or-less the way one
%would expect them to. The \texttt{set!-values} form evaluates an
%expression and destructures it according to the formals, assigning each
%variable to that part of the returned values. \texttt{letrec-values} is
%\texttt{letrec}, except each right-hand-side is destructured according
%to the formals. \texttt{letrec*-values} is \texttt{letrec-values} but
%sequential.}
%
%\note[item]{The definitions of a \texttt{lambda} form are
%translated into \texttt{letrec*-values} forms, in order to treat
%\texttt{define-values} as a primitive.}
%\end{frame}

\begin{frame}[fragile]
\frametitle{What is in the \rnrs{7}-Large --- Anonymous recursive expressions}
\begin{verbatim}
(map (rec (fact n)
       (if (<= n 1) 1
           (* n (fact (- n 1)))))
     '(1 2 3 4 5))
         ; => (1 2 6 24 120)
(car (force (cdr (rec s
                   (cons 1 (delay s))))))
         ; => 1
\end{verbatim}

\note[item]{The \rnrs{7}-Large also adds a macro for anonymous recursive
expressions: it's a thin wrapper over \texttt{letrec}.}

\note[item]{The most obvious usage is for anonymous recursive procedures,
like this factorial function. It can be useful when passed to higher order
functions, like in the example here, which calculates the factorial of each
number in the list.}

\note[item]{Being a way to create recursive expressions, it can also
construct complicated expressions that hide \texttt{lambda}s, like the
\texttt{delay} expression in the second example. The recursive expression
creates an infinite lazy list that is traversed by the \texttt{car}s,
\texttt{cdr}s, and \texttt{force} invocations.}
\end{frame}

\begin{frame}[fragile]
\frametitle{What is in the \rnrs{7}-Large --- Define higher-order \texttt{lambda}}
\begin{columns}
\begin{column}{0.45\textwidth}
\begin{verbatim}
(define ((addn n) x)
  (+ n x))
\end{verbatim}
\end{column}
\begin{column}{0.45\textwidth}
\begin{verbatim}
(define addn
  (lambda (n)
    (lambda (x)
      (+ n x))))
\end{verbatim}
\end{column}
\end{columns}

\begin{verbatim}
(map (addn 10) '(1 2 3 4 5))
  ; => (11 12 13 14 15)
\end{verbatim}

\note[item]{The \rnrs{7}-Large also standardizes the popular define
higher order \texttt{lambda} extension, which originates from MIT Scheme
and was adopted by many other implementations. It allows one to write
procedures that return procedures in a simple way. In the example here,
the \texttt{addn} procedure returns a procedure that adds \texttt{n}
to the input argument. It makes using higher-order procedures like
\texttt{map} easier.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large --- Other extensions}
\begin{itemize}
\item fixed \texttt{when} and \texttt{unless}
\item aligned \texttt{letrec} and \texttt{letrec*}
\item \texttt{(cond) =>} unspecified
\item \texttt{(case x) =>} unspecified
\item definitions in \texttt{when}, \texttt{unless}, \texttt{cond}, and \texttt{case}
\end{itemize}

\note[item]{The \rnrs{7}-Large also does some cleanup work to make
some of the forms more consistent, or to clean up issues with the
original \rnrs{7}.}

\note[item]{The definition of \text{when} and \text{unless} in the \rnrs{7}
required it to tail-call its final expression and to always return a single
unspecified value, even if the final expression returned multiple values.
This contradicted the sample implementation, and no Scheme implementation
I could find always returned a single unspecified value from these forms.
The \rnrs{7}-Large changes this so that the forms can return any number
of unspecified values.}

\note[item]{The definition of \texttt{letrec} did not ban the
re-invocation of the continuation of a right-hand side, the
way that \texttt{letrec*} does. The \rnrs{7}-Large aligns both
behaviors. Conditional forms with no matching clauses return an
unspecified value.}

\note[item]{Finally, the conditional forms have their sequence forms replaced
with body forms. So one can use internal \texttt{define}s in the right hand
side of a \texttt{cond} without wrapping it in \texttt{let}.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large?}

Split into 7 \textit{fascicles}:

\begin{itemize}
\item \textcolor{bg!85!normal text.fg}{The Macrological Fascicle (macros) {\footnotesize (October 2024)}}
\item \textcolor{bg!85!normal text.fg}{The Procedural Fascicle (procedural programming) {\footnotesize (May 2026)}}
\item {The Valued Fascicle (Scheme values)}
\item \textcolor{bg!85!normal text.fg}{The Erroneous Fascicle (error system)}
\item \textcolor{bg!85!normal text.fg}{The Bibliothecarial Fascicle (library system)}
\item \textcolor{bg!85!normal text.fg}{The Flow-Controlling Fascicle (continuations)}
\item \textcolor{bg!85!normal text.fg}{The Record-Winning Fascicle (record type system)}
\end{itemize}
\note[item]{The third fascicle is almost done: hopefully it will be released
before the end of the year. It will encompass the basic Scheme value types,
such as pairs and strings. Much of this material has been discussed and
approved by the Working Group, but has not been ratified by the community at large
in a ballot.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large?}
\begin{columns}
\begin{column}{0.50\textwidth}
\textbf{String and bytevector features}
\begin{itemize}
\item<2->{Full Unicode support}
\item<2->{Raw string literals}
\item<2->{String-notated bytevectors}
\end{itemize}
\end{column}
\begin{column}{0.50\textwidth}
\textbf{Number features}
\begin{itemize}
\item<3->{Full numeric tower}
\item<3->{Type-specific number vectors (\texttt{u32vector}, \texttt{f64vector})}
\item<3->{Bitwise arithmetic}
\item<3->{Fixnums and flonums}
\item<3->{Division procedures}
\item<3->{Underscores in numbers}
\end{itemize}
\end{column}
\end{columns}

\note[item]<1>{This fascicle has lots of small changes. The changes we
will focus on are the changes to strings and bytevectors, and the changes
to numbers.}

\note[item]<2>{The \rnrs{7}-Large will include the full Unicode support
that the \rnrs{6} required, and also adds some new reader syntax that
makes it easier to write some strings and bytevectors without escapes.}

\note[item]<3>{The \rnrs{7}-Large will include the full numeric tower of
the \rnrs{6}, type specific number vectors such as \texttt{u32vector},
an expanded version of the fixnum and flonum procedures from the
\rnrs{6}, a large set of integer division procedures, and an extension
to support underscores in numbers.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large? --- Unicode}
\begin{itemize}
\item<1->{Implementations must support all and only the Unicode scalar values as characters and in strings}
  \begin{itemize}
    \item<1->{\rnrs{7} only requires a subset of ASCII}
    \item<1->{\rnrs{7} allows for characters with values above \texttt{\#x10FFFF}}
    \item<1->{Excludes surrogate codepoints}
  \end{itemize}
\item<2->{Implementations must case-fold according to the default Unicode
case-folding rules}
  \begin{itemize}
    \item<2->{\texttt{(string-foldcase "}StRaße\texttt{") => "strasse"}}
  \end{itemize}
\item<2->{Implementations will have to allow Unicode in identifiers}
  \begin{itemize}
    \item<2->\texttt{(define }$\surd 2$\texttt{ (sqrt 2))}
  \end{itemize}
\end{itemize}

\note[item]<1>{Implementations must support all of and only the
Unicode scalar values, which are the non-surrogate codepoints.
The \rnrs{7} only required implementations to support the
non-NUL ASCII characters and also allowed non-Unicode characters by
allowing characters to have numerical values above any Unicode codepoint.
These features were seldom used, so support for them was dropped in
the \rnrs{7}-Large.}

\note[item]<1>{This also means that surrogate codepoints are not characters.
This is the case in the \rnrs{6}. Surrogate codepoints will have subtly
different behavior on different implementations, as some use them for escaping.
In addition, requiring lone surrogate handling would complicate implementing
the \rnrs{7}-Large on systems that use UTF-16.}

\note[item]<2>{Another addition, carried over from the \rnrs{6}, is that
implementations must implement the default Unicode case-folding rules
and implement Unicode for identifiers in a specified way that was specified
in the \rnrs{6} and was optional in the \rnrs{7}. As you can see here,
this definition, which is valid in \rnrs{6}, is now valid in \rnrs{7}-Large.}
\end{frame}

\begin{frame}[fragile]
\frametitle{What is in the \rnrs{7}-Large? --- Raw String Literals}
\begin{itemize}
\item<1->{Write strings with backslashes and double quotes inside of them
without escapes}
\item<1->{Popular extension in other languages (C++, Python, Rust)}
\item<2-> Syntax: \verb|#"| \textit{delim} \verb|"| \textit{text} \verb|"| \textit{delim}\verb|"|
\item<3-> Examples:
    {\verb|#""This is my "string\n".""|
     \verb| => "This is my \"string\\\n\"."|}

    {\verb|#"delim"#""string"""delim"|
          \verb| => "#\"\"string\"\""|}
\item<3-> \textbf{An arbitrary string can be embedded as-is with a suitable
choice of delimiter.}
\end{itemize}

\note[item]<1>{Another extension we have introduced is raw string
literals. Raw string literals allow one to write strings that contain
a lot of double quotes and backslashes without escaping them. They are
useful when embedding another syntax inside of a string, such as JSON or
SQL. They are a popular extension in other languages, like C++, Python,
and Rust.}

\note[item]<2>{The syntax of a raw string literal starts with a hash followed
by the delimiter sequence. The delimiter sequence is zero or more characters
surrounded by double quotes. Then after the delimiter sequence is the string
data interpreted without escapes, until the delimiter sequence is read again.}

\note[item]<3>{Here are some examples to demonstrate. The first one has the
smallest delimiter sequence, which is two double quotes. Hence the appearance
of two double quotes terminates the raw string. The double quotes and the
backslashes that do not terminate the string are kept as-is.}

\note[item]<3>{The second example shows a raw string with a custom delimiter.
This allows us to write a raw string in a raw string without escaping. The
moral is, raw strings allow us to include a string verbatim in the source code
of a program, given a suitable choice for a delimiter.}
\end{frame}

\begin{frame}[fragile]
\frametitle{What is in the \rnrs{7}-Large? --- String-notated bytevectors}
\begin{itemize}
\item<1-> Write bytevectors like strings
\item<1-> Useful for dealing with binary data that includes
          ASCII components
\item<2-> Syntax: \verb|#u8"| \textit{string bytevector elements} \verb|"|
  \begin{itemize}
  \item<2-> \textit{string bytevector element} is either an ASCII character
             or an octet
  \end{itemize}
\item<3-> ELF header: \verb|#u8"\x7F;ELF"|
  \begin{itemize}
    \item<3-> Equivalent to \verb|#u8(#x7F #x45 #x4C #x46)|
  \end{itemize}
\item<3-> PNG header: \verb|#u8"\x89;PNG\r\n\x1A;\n"|
  \begin{itemize}
    \item<3-> \verb|#u8(#x89 #x50 #x4E #x47 #x0D #x0A #x1A #x0A)|
  \end{itemize}
\item<4-> \rnrs{7}-Large does not allow Unicode characters
          in string-notated bytevectors
\end{itemize}

\note[item]<1>{The \rnrs{7}-Large also adds string-notated bytevectors. These
are useful when one wants to write a bytevector that includes human-readable
sections in ASCII.}

\note[item]<2>{The syntax for string-notated bytevectors is very similar to
strings. The only difference is that they start with \texttt{\#u8} instead of
just a double quote. Inside of them, the \texttt{\textbackslash x} escape sequence means
octet, not Unicode codepoint.}

\note[item]<3>{Here are some examples of string-notated bytevectors. The
first one is the ELF header. Note the use of \texttt{\textbackslash x7F;} to mean the
octet \texttt{\textbackslash x7F;}. In this case, the octet and the UTF-8 encoded character
U+7F coincide, but this is not the case in general. You can see this in
the next example, the PNG header. Here the \texttt{\textbackslash x89;} inserts the literal
byte \texttt{\textbackslash x89;}. Escapes that correspond to ASCII escapes are allowed, so
\texttt{\textbackslash n} is the ASCII newline.}

\note[item]<4>{In general, the \rnrs{7}-Large does not allow Unicode
characters in string-notated bytevectors.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large? --- Full numeric tower}

\begin{itemize}
\item Arbitrarily large exact integers and rationals
\item Exact and inexact complex numbers
\item Signed inexact zero, infinities, and NaNs
\item \texttt{(atan +0.0+1.0i) =>} $\pi/4$\texttt{+inf.0i}
\item \texttt{(atan -0.0+1.0i) =>} $-\pi/4$\texttt{+inf.0i}
\end{itemize}

\note[item]{The \rnrs{6} numeric tower is adopted in full. This means
that bignums, arbitrarily large exact rationals, and exact and inexact
complex numbers must be supported. In addition,
optional features like signed zero, infinities, and NaNs are now required.
This allows code to be more precise and more portable.}

\note[item]{This means that the behavior of functions sensitive to
the sign of zero and that return infinities will now behave more
portably across implementations, such as complex \texttt{atan} here.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large? --- Type-specific number vectors}
\begin{itemize}
\item<1-> Optimized vectors for storing certain types of numbers
\item<2-> two's-complement and unsigned 8, 16, 32, and 64 bit integers
\item<2-> \texttt{\#s32(1 -2 3 -4)}
\item<3-> binary32 and binary64 floating-point numbers
\item<3-> \texttt{\#f64(1.0 2.0)}
\item<4-> inexact complex numbers comprised of binary32 and binary64
          numbers respectively
\item<4-> \texttt{\#c128(1.0+2.0i 3.0+4.0i)}
\end{itemize}

\note[item]<1>{The \rnrs{7}-Large also adds type specific number vectors.
These could be implemented atop bytevectors in the \rnrs{6}, but the
dedicated type specific vectors are a popular extension.}

\note[item]<2>{The integer number vectors come in signed and unsigned
varieties, and are sized to contain 8, 16, 32, and 64 bit numbers. The
8-bit unsigned number vector is specified to be the same as a bytevector.
Here is an example of a signed 32-bit number vector.}

\note[item]<3>{The inexact real number vectors come in binary32 and
binary64 variants. The \rnrs{7}-Large is slightly stricter than the
SRFIs, as we now mandate the type stored in the number vector. Here
is an example of a binary64 number vector.}

\note[item]<4>{There are also complex number vectors, comprised of
binary32 and binary64 numbers respectively.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large? --- Bitwise arithmetic}
\begin{itemize}
\item In the Foundations, a core set of bitwise operators for infinite
      bitstrings
  \begin{itemize}
    \item \texttt{bitwise-not}, \texttt{bitwise-and}, \texttt{bitwise-ior},
          \texttt{bitwise-xor}, \texttt{arithmetic-shift},
          \texttt{integer-length}, and \texttt{bit-count}
  \end{itemize}
\item In the whole \rnrs{7}-Large, a superset of the \rnrs{6} procedures
\end{itemize}

\note[item]{The \rnrs{7}-Large will include a facility for bitwise
arithmetic over bignums. The Foundations will only include a core set
of operators that are sufficient to implement the rest in an efficient
way. The whole report will include a superset of the \rnrs{6} procedures.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large? --- Flonums}
\begin{itemize}
\item<1->{Type specific operations on inexact real numbers}
\item<1->{Includes the \rnrs{6} API: \texttt{fl+}, \texttt{flsqrt}, etc.}
\item<2->{Includes the C99 \texttt{math.h} API}
  \begin{itemize}
    \item<2->{Accessors: \texttt{flnormalized-fraction-exponent} equivalent to \texttt{frexp}}
    \item<2->{Specialized operations: \texttt{flremquo}}
    \item<2->{More accurate procedures: \texttt{fllog1+} equivalent to $\log(x+1)$.}
    \item<2->{Maybe: IEEE 754-2019 extensions}
  \end{itemize}
\end{itemize}

\note[item]<1>{The \rnrs{7}-Large will include a large superset of the
\rnrs{6}'s flonum library. Included will be equivalents to many of the
generic arithmetic procedures, like square root, exponential and logarithm.}

\note[item]<2>{The flonum library will also include functions from the
C99 \texttt{math.h} library. These include flonum accessors, such as
an equivalent to \texttt{frexp}, specialized operations such as
\texttt{flremquo}, and procedures that can compute certain operations
more accurately, such as $\log(x+1)$. We might look into including more
IEEE 754-2019 recommended operations, which appear in C23.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large? --- Division procedures}
\begin{itemize}
\item There are many ways to do integer division, depending on the desired properties on the quotient/remainder
\item Given numerator $n$ and denominator $d$, compute integers $q$ and $r$ such that
$n = qd + r$ and $|r| < |d| $
\item \rnrs{7}-Large will include multiple integer division procedures
  \begin{itemize}
    \item \texttt{floor/} (in \rnrs{7})
    \item \texttt{truncate/} (in \rnrs{7})
    \item \texttt{euclidean/} (similar to \rnrs{6} \texttt{div-and-mod})
    \item \texttt{balanced/} (similar to \rnrs{6} \texttt{div0-and-mod0})
    \item \texttt{ceiling/}
    \item \texttt{round/}
  \end{itemize}
\end{itemize}

\note[item]{In many languages there is only one integer division pair.
The \rnrs{7}-Large will include a very large selection of
integer division operators.}

\note[item]{This is the complete list of the integer division operators. Two
were included in the \rnrs{7}, and two were included in the \rnrs{6}. The
\rnrs{7} operators are based off of two integer rounding procedures, and the
\rnrs{6} procedures are based off of two constraints on the remainder. The
other procedures, \texttt{ceiling/} and \texttt{round/}, implement the pairs
based off of the other IEEE 754 integer rounding procedures.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large? --- Underscores in numbers}
\begin{itemize}
\item<1-> Being able to add digit separators to numbers is a common and useful
          feature in other languages
  \begin{itemize}
    \item<1-> C++: \texttt{1'000'000}
    \item<1-> Python: \texttt{10\_00\_00}
  \end{itemize}
\item<1-> The \rnrs{7}-Large allows an underscore between digits.
  \begin{itemize}
    \item<2-> \texttt{\#b10110000\_11011101}
    \item<2-> \texttt{\#x7FFF\_FFFF\_FFFF\_FFFF}
  \end{itemize}
\item<3-> Only one underscore is portable: implementations may extend
  the syntax to more locations.
\end{itemize}

\note[item]<1>{To round off the major new features for numbers is the
addition of underscores in numbers. Underscores in numbers have no
effect on the value of the number: they make the number easier for humans
to read. Such a feature is a very common extension, as seen in C++ and
Python.}

\note[item]<2>{Here are some examples of the new syntax. As you can see,
it's easier to tell that the first number is 16 bits, and that the
second number is 64 bits.}

\note[item]<3>{Only one underscore between two digits is portable,
although implementations may allow more underscores. This is because the
Scheme number syntax is complicated, and doing things like prefixing or
suffixing something with underscores may be intended by the programmer
to be an identifier instead of a number.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large? --- Much more}

\begin{itemize}
\item Fixnums (superset of \rnrs{6} library)
\item Hyperbolic and inverse hyperbolic functions
\item \texttt{conjugate} procedure
\item Extensions to many procedures (\texttt{utf8->string}, \texttt{assoc}, etc.)
\end{itemize}

\note[item]{There are many comparatively small things that we have
added to the \rnrs{7}-Large in this fascicle that did not merit
their own slide. However, we think that adding them will be a benefit
for the language.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large?}

Split into 7 \textit{fascicles}:

\begin{itemize}
\item \textcolor{bg!85!normal text.fg}{The Macrological Fascicle (macros) {\footnotesize (October 2024)}}
\item \textcolor{bg!85!normal text.fg}{The Procedural Fascicle (procedural programming) {\footnotesize (May 2026)}}
\item \textcolor{bg!85!normal text.fg}{The Valued Fascicle (Scheme values)}
\end{itemize}

The following are in the planning stages:

\begin{itemize}
\item {The Erroneous Fascicle (error system)}
\item {The Bibliothecarial Fascicle (library system)}
\item {The Flow-Controlling Fascicle (continuations)}
\item {The Record-Winning Fascicle (record type system)}
\end{itemize}
\note[item]{The final four fascicles are in the early planning stages.
However, the bulk of the procedures were defined in the third fascicle,
so hopefully drafting these should be simpler. As such, I will have
less to say about them.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large?}

Split into 7 \textit{fascicles}:

\begin{itemize}
\item \textcolor{bg!85!normal text.fg}{The Macrological Fascicle (macros) {\footnotesize (October 2024)}}
\item \textcolor{bg!85!normal text.fg}{The Procedural Fascicle (procedural programming) {\footnotesize (May 2026)}}
\item \textcolor{bg!85!normal text.fg}{The Valued Fascicle (Scheme values)}
\item {The Erroneous Fascicle (error system)}
\item \textcolor{bg!85!normal text.fg}{The Bibliothecarial Fascicle (library system)}
\item \textcolor{bg!85!normal text.fg}{The Flow-Controlling Fascicle (continuations)}
\item \textcolor{bg!85!normal text.fg}{The Record-Winning Fascicle (record type system)}
\end{itemize}

\note[item]{The fourth fascicle will describe the error raising requirements
and the condition system.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large? --- Error system}

\begin{itemize}
\item<1-> The \rnrs{7} has an exception system that is a subset of \rnrs{6}
  \begin{itemize}
    \item<1-> \texttt{with-exception-handler}, \texttt{raise}, \texttt{guard}
    \item<1-> ``it is an error'' (undefined behavior)
  \end{itemize}
\item<2-> Most \rnrs{7} implementations raise exceptions on type errors
  \begin{itemize}
    \item<2-> \texttt{(cdr '()) => } \textit{exception}
    \item<2-> CHICKEN 6, Chibi Scheme, Gauche, Gambit, MIT-Scheme, ...
  \end{itemize}
\item<3-> The \rnrs{6} specifies exception object system, and condition hierarchy
  \begin{itemize}
    \item<3-> Most errors raise exceptions
  \end{itemize}
\item<4->\textbf{What condition system to use?}
  \begin{itemize}
    \item<4-> The \rnrs{6} condition system, likely
  \end{itemize}
\item<5->\textbf{What error raising behavior to use?}
  \begin{itemize}
    \item<5-> \rnrs{6} style? (No extensions allowed)
    \item<5-> Extensions allowed with restrictions?
  \end{itemize}
\item<5-> We will look to the community for guidance.
\end{itemize}

\note[item]<1>{The \rnrs{7} had a very small exception handling and error
raising system. The exception handling system is a subset of the
\rnrs{6}'s system.}

\note[item]<1>{The \rnrs{7} specifies that ``it is an error'' when
the language is used incorrectly, such as trying to take the cdr of the
empty list. This jargon is basically undefined behavior: an implementation
can take any action whatsoever.}

\note[item]<2>{In practice, errorful situations don't cause segmentation
faults or memory corruption. Most implementations raise exceptions and
implement some sort of way of inspecting those exceptions.}

\note[item]<3>{The \rnrs{6} has a complete exception object system, with
a standard set of exception types that one can subclass. In the \rnrs{6},
most misuses of the language raise ``assertion violations.''}

\note[item]<4>{So what condition object system will we use for the
\rnrs{7}-Large? We will likely use the \rnrs{6} condition hierarchy.
However, we don't know how much of the \rnrs{6} condition object system
we will use.}

\note[item]<5>{What are the requirements for raising exceptions? Should we
take the \rnrs{6} position of no extensions to the standard procedures,
or should we be more flexible? We will try to poll people in the community
to figure out the answer.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large?}

Split into 7 \textit{fascicles}:

\begin{itemize}
\item \textcolor{bg!85!normal text.fg}{The Macrological Fascicle (macros) {\footnotesize (October 2024)}}
\item \textcolor{bg!85!normal text.fg}{The Procedural Fascicle (procedural programming) {\footnotesize (May 2026)}}
\item \textcolor{bg!85!normal text.fg}{The Valued Fascicle (Scheme values)}
\item \textcolor{bg!85!normal text.fg}{The Erroneous Fascicle (error system)}
\item {The Bibliothecarial Fascicle (library system)}
\item \textcolor{bg!85!normal text.fg}{The Flow-Controlling Fascicle (continuations)}
\item \textcolor{bg!85!normal text.fg}{The Record-Winning Fascicle (record type system)}
\end{itemize}

\note[item]{The fifth fascicle will describe libraries and programs.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large? --- Library syntax}
\begin{itemize}
\item<1->{The \rnrs{7} has \texttt{define-library}}
\item<1->{The \rnrs{6} has \texttt{library}, phase information, versions}
\item<2->{Both forms will be included}
  \begin{itemize}
    \item<2-> Versions specs likely syntactically valid but ignored
    \item<2-> Implicit phasing mandated
    \item<2-> The \texttt{import} and \texttt{export} forms in both
              formats will be identical
  \end{itemize}
%\item<3-> The \rnrs{6} and \rnrs{7} have different expansion orders
%          for toplevel programs
%\begin{itemize}
%  \item<3-> \rnrs{7} programs have a sequential expansion order (like a REPL)
%  \item<3-> \rnrs{6} programs have a mutual expansion order (macros defined
%     later in the file can be used earlier in the file)
%\end{itemize}
%\item<3-> We will have to find some way to deal with these.
\end{itemize}

\note[item]<1>{The \rnrs{6} and \rnrs{7} have different forms for
describing the contents of a library. The \rnrs{7} \texttt{define-library}
has provisions for conditional imports and including text files, while
the \rnrs{6} \texttt{library} form has provisions for import phases and
versions. The \rnrs{7}-Large will have to deal with this.}

\note[item]<2>{What we plan to do is to offer both syntactic forms.
Library version specs will likely be syntactically valid but ignored, and we
will mandate an implicit phasing model which means that phase information
will also be syntactically valid but ignored.}

\end{frame}

\begin{frame}[fragile]
\frametitle{What is in the \rnrs{7}-Large? --- Top-level expansion order}
The \rnrs{6} and \rnrs{7} have different expansion orders.

\begin{columns}
\begin{column}{0.50\textwidth}
\small
\begin{uncoverenv}<2->
\textbf{\rnrs{6}}: Mutual expansion
\begin{Verbatim}[commandchars=\\\{\}]
(define (f x) (\textcolor{RedOrange}{macro} 10 x))
(\textcolor{blue}{define-syntax macro}
  (syntax-rules ()
    ((_ a b) (+ a b))))
(display (f 100)) ; "110"
\end{Verbatim}
This program is \emph{invalid} in \rnrs{7}, because
\texttt{macro} is used before definition.
\end{uncoverenv}
\end{column}
\begin{column}{0.50\textwidth}
\small
\begin{uncoverenv}<3->
\textbf{\rnrs{7}}: REPL-like expansion
\begin{Verbatim}[commandchars=\\\{\}]
(define-syntax macro
  (syntax-rules ()
    ((_ x y) (+ x y))))
(define (f x) (macro x 10))
(\textcolor{RedOrange}{define-syntax macro}
  (syntax-rules ()
    ((_ x y) (- x y))))
(define (g x) (macro x 10))
(display (f 100)) ; "110"
(display (g 100)) ; "90"
\end{Verbatim}
This program is \emph{invalid} in \rnrs{6}, because
\texttt{macro} is defined twice.
\end{uncoverenv}
\end{column}
\end{columns}
\note[item]<1>{One major issue we will have to reconcile at this point
is the different expansion orders of the \rnrs{6} and \rnrs{7}.}

\note[item]<2>{The \rnrs{6} has what I will call a mutual expansion
order. Macros defined later on in a top-level program are usable earlier
on in the program. In the example on the screen, the orange text denotes
a macro use that appears before the macro definition later on in
blue. Note that this program acts differently than if one input the
text of the program into a REPL.}

\note[item]<3>{On the other hand, \rnrs{7} has what I call a REPL-like
expansion order. Definitions are executed sequentially, and new
definitions with the same name overwrite previous definitions. Here,
the first definition of \texttt{macro} is used in the definition of
the procedure \texttt{f}, and the second definition of \texttt{macro}
(in orange) is used in the definition of the procedure \texttt{g}.
This is invalid in the \rnrs{6}, because the same identifier is defined
twice.}

\note[item]<3>{We don't have a solution for any of this yet.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large?}

Split into 7 \textit{fascicles}:

\begin{itemize}
\item \textcolor{bg!85!normal text.fg}{The Macrological Fascicle (macros) {\footnotesize (October 2024)}}
\item \textcolor{bg!85!normal text.fg}{The Procedural Fascicle (procedural programming) {\footnotesize (May 2026)}}
\item \textcolor{bg!85!normal text.fg}{The Valued Fascicle (Scheme values)}
\item \textcolor{bg!85!normal text.fg}{The Erroneous Fascicle (error system)}
\item \textcolor{bg!85!normal text.fg}{The Bibliothecarial Fascicle (library system)}
\item {The Flow-Controlling Fascicle (continuations)}
\item \textcolor{bg!85!normal text.fg}{The Record-Winning Fascicle (record type system)}
\end{itemize}

\note[item]{Moving on to the next fascicle, which will cover continuations
and continuation-related matters.}
\end{frame}

\begin{frame}
\frametitle{Delimited and composable continuations}
\begin{itemize}
\item<1-> Delimited continuations capture part of a computation, not the
          whole computation (\texttt{call/cc})
\item<1-> Delimited continuations are popular
  \begin{itemize}
    \item<1-> Gauche, Sagittarius, Racket, and Guile
  \end{itemize}
\item<2-> Racket-inspired proposal for Scheme: SRFI 226 (followed by Gauche and Sagittarius)
  \begin{itemize}
    \item<3-> Prompts: \texttt{call-with-continuation-prompt}, \texttt{abort-current-continuation}
    \item<3-> Composable continuations: \texttt{call-with-composable-continuation}
    \item<3-> Continuation barriers: \texttt{call-with-continuation-barrier}
    \item<3-> Continuation marks: \texttt{with-continuation-marks}
    \item<3-> Integration with threads, interrupts, promises, and fluids
  \end{itemize}
\end{itemize}

\note[item]<1>{Scheme has had reified continuations in the form of
\texttt{call/cc} for a long time, but over time people have developed
the concept of delimited continuations.
Delimited continuations capture part of a computation, not the whole
computation like \texttt{call/cc} does. Delimited continuations as a
primitive operation are included in more Scheme implementations: Racket,
Gauche, Sagittarius, and Guile.}

\note[item]<2>{For \rnrs{7}-Large, Marc Nieper-Wi\ss{}kirchen has written
a very comprehensive proposal, SRFI 226. Sagittarius implements the entire
proposal, and Gauche is in the process of implementing it.}

\note[item]<3>{The proposal covers prompts, composable continuations,
continuation barriers, continuation marks, and integration of these
things with threads, interrupts, promises, and fluids.}
\end{frame}

\begin{frame}[fragile]
\frametitle{Delimited and composable continuations --- Example}
Implementation of \texttt{shift} and \texttt{reset}.

\begin{columns}
\footnotesize
\begin{column}{0.40\textwidth}
\begin{uncoverenv}<2->
\begin{Verbatim}[commandchars=\\\{\}]
(define-syntax reset
  (syntax-rules ()
    [(reset e1 e2 ...)
     (\textcolor{RedOrange}{call-with-continuation-prompt}
      (lambda ()
        e1 e2 ...))]))
\end{Verbatim}
\end{uncoverenv}
\end{column}
\begin{column}{0.60\textwidth}
\begin{uncoverenv}<3->
\begin{Verbatim}[commandchars=\\\{\}]
(define-syntax shift
  (syntax-rules ()
    [(shift k e1 e2 ...)
     (\textcolor{RedOrange}{call-with-composable-continuation}
      (lambda (\textcolor{RedOrange}{c})
        (define (k . args)
          (reset (apply c args)))
        (abort-current-continuation
         (default-continuation-prompt-tag)
         (lambda ()
           e1 e2 ...))))]))
\end{Verbatim}
\end{uncoverenv}
\end{column}
\end{columns}
\vspace{24pt}
(Nieper-Wi\ss{}kirchen. ``SRFI 226: Control features.'' (2023))

\note[item]<1>{There is a lot
here that has been covered in other places in more detail, so I will
not go into many details here. However, I will go over an example of
how the common operators \texttt{shift} and \text{reset} are implemented
in terms of SRFI 226 continuations.}

\note[item]<2>{\texttt{Reset} is implemented by installing a continuation
prompt. Prompts have tags that identify the prompt and an abort handler.
The default tag is a fixed value that is returned by
\text{default-continuation-prompt-tag}. The default abort handler re-instates
the prompt and then calls a thunk.}

\note[item]<3>{\texttt{Shift} is implemented by capturing a composable
continuation up to, but not including a given prompt tag. The default prompt
tag is the same tag as the one installed by \texttt{reset}. The composable
continuation here is called \texttt{c}.}
\end{frame}

\begin{frame}[fragile]
\frametitle{Delimited and composable continuations --- Example}
Implementation of \texttt{shift} and \texttt{reset}.

\begin{columns}
\footnotesize
\begin{column}{0.40\textwidth}
\begin{Verbatim}[commandchars=\\\{\}]
(define-syntax reset
  (syntax-rules ()
    [(reset e1 e2 ...)
     (call-with-continuation-prompt
      (lambda ()
        e1 e2 ...))]))
\end{Verbatim}
\end{column}
\begin{column}{0.60\textwidth}
\begin{Verbatim}[commandchars=\\\{\}]
(define-syntax shift
  (syntax-rules ()
    [(shift k e1 e2 ...)
     (call-with-composable-continuation
      (lambda (c)
        (define (\textcolor{RedOrange}{k} . args)
          (\textcolor{RedOrange}{reset} (apply c args)))
        (abort-current-continuation
         (default-continuation-prompt-tag)
         (lambda ()
           e1 e2 ...))))]))
\end{Verbatim}
\end{column}
\end{columns}
\vspace{24pt}
(Nieper-Wi\ss{}kirchen. ``SRFI 226: Control features.'' (2023))

\note[item]{We want the continuation  to have the prompt
available when we call it, so we make a wrapper \texttt{k} that
wraps the captured composable continuation \texttt{c} with a
\texttt{reset} to accomplish that.}
\end{frame}

\begin{frame}[fragile]
\frametitle{Delimited and composable continuations --- Example}
Implementation of \texttt{shift} and \texttt{reset}.

\begin{columns}
\footnotesize
\begin{column}{0.40\textwidth}
\begin{Verbatim}[commandchars=\\\{\}]
(define-syntax reset
  (syntax-rules ()
    [(reset e1 e2 ...)
     (call-with-continuation-prompt
      (lambda ()
        e1 e2 ...))]))
\end{Verbatim}
\end{column}
\begin{column}{0.60\textwidth}
\begin{Verbatim}[commandchars=\\\{\}]
(define-syntax shift
  (syntax-rules ()
    [(shift k e1 e2 ...)
     (call-with-composable-continuation
      (lambda (c)
        (define (k . args)
          (reset (apply c args)))
        (\textcolor{RedOrange}{abort-current-continuation}
         (default-continuation-prompt-tag)
         (lambda ()
           e1 e2 ...))))]))
\end{Verbatim}
\end{column}
\end{columns}
\vspace{24pt}
(Nieper-Wi\ss{}kirchen. ``SRFI 226: Control features.'' (2023))

\note[item]{Then we abort the continuation to the prompt that we
instated using \texttt{reset}. The default abort handler will
re-instate the continuation, and then execute the thunk we passed
it, which contains the body of the \texttt{shift} statement.}
\end{frame}

%\begin{frame}[fragile]
%\frametitle{Delimited and composable continuations --- Example}
%Usage of \texttt{shift} and \texttt{reset}.
%\begin{columns}
%\begin{column}{0.40\textwidth}
%\begin{Verbatim}[commandchars=\\\{\}]
%(+
% 1
% (reset
%   (* 2 (shift k
%          (k (k 4))))))
%\end{Verbatim}
%\end{column}
%\begin{column}{0.60\textwidth}
%\end{column}
%\end{columns}
%
%\note[item]<1>{Now I will move on to a quick example of our newly
%defined \texttt{shift} and \texttt{reset}. To the left is an expression
%we will evaluate.}
%\end{frame}
%
%\begin{frame}[fragile]
%\frametitle{Delimited and composable continuations --- Example}
%Usage of \texttt{shift} and \texttt{reset}.
%\begin{columns}
%\begin{column}{0.40\textwidth}
%\begin{Verbatim}[commandchars=\\\{\}]
%(+
% 1
% (\textcolor{RedOrange}{reset}
%   (* 2 (\textcolor{RedOrange}{shift} k
%          (k (k 4))))))
%\end{Verbatim}
%\end{column}
%\begin{column}{0.60\textwidth}
%\begin{verbatim}
%k = (lambda (x)
%      (reset (* 2 x)))
%\end{verbatim}
%\end{column}
%\end{columns}
%
%\note[item]<1>{When we evaluate the \texttt{reset}, we install a
%continuation prompt at the multiplication by 2. Then, when we evalutate
%the \texttt{shift}, first we capture a continuation up to and including
%the prompt. The \texttt{k} on the right hand side is the equivalent
%function of the \texttt{k} captured by \texttt{shift}.}
%\end{frame}
%
%\begin{frame}[fragile]
%\frametitle{Delimited and composable continuations --- Example}
%Usage of \texttt{shift} and \texttt{reset}.
%\begin{columns}
%\begin{column}{0.40\textwidth}
%\begin{Verbatim}[commandchars=\\\{\}]
%(+ 1 (reset (k (k 4))))
%\end{Verbatim}
%\begin{uncoverenv}<2>
%\texttt{=> 17}
%\end{uncoverenv}
%\end{column}
%\begin{column}{0.60\textwidth}
%\begin{verbatim}
%k = (lambda (x)
%      (reset (* 2 x)))
%\end{verbatim}
%\end{column}
%\end{columns}
%
%\note[item]<1>{Then we abort the continuation up to and including the
%prompt, and then re-instate the prompt. So what we are evaluating is
%now the left hand side. Without any more \texttt{shift}s, the
%\texttt{reset}s don't do anything here.}
%
%\note[item]<2>{Everything else is a normal evaluation, and the final
%answer is 17.}
%\end{frame}

\begin{frame}
\frametitle{Multithreading}
\begin{itemize}
\item Many implementations have preemptive multithreading
  \begin{itemize}
    \item Chibi, Capy, Chez, CHICKEN, Cyclone, Gambit and more
  \end{itemize}
\item Specification: SRFI 18
  \begin{itemize}
    \item \texttt{make-thread}, \texttt{thread-specific},
          \texttt{thread-start!}, \texttt{thread-yield!},
          \texttt{thread-sleep!}, \texttt{mutex-lock!}, ...
  \end{itemize}
\end{itemize}

\note[item]{Another thing we want to introduce at this stage is a standard
multithreading library. Multithreading is a part of multiple popular
implementations, and there is already a mature specification for such a
thing written by Marc Feeley all the way back in 2001.}

\note[item]{The proposal covers many things that one expects in a
multithreading system, like mutexes and thread-local storage. So I won't
go over it here.}
\end{frame}

\begin{frame}
\frametitle{What is in the \rnrs{7}-Large?}

Split into 7 \textit{fascicles}:

\begin{itemize}
\item \textcolor{bg!85!normal text.fg}{The Macrological Fascicle (macros) {\footnotesize (October 2024)}}
\item \textcolor{bg!85!normal text.fg}{The Procedural Fascicle (procedural programming) {\footnotesize (May 2026)}}
\item \textcolor{bg!85!normal text.fg}{The Valued Fascicle (Scheme values)}
\item \textcolor{bg!85!normal text.fg}{The Erroneous Fascicle (error system)}
\item \textcolor{bg!85!normal text.fg}{The Bibliothecarial Fascicle (library system)}
\item \textcolor{bg!85!normal text.fg}{The Flow-Controlling Fascicle (continuations)}
\item {The Record-Winning Fascicle (record type system)}
\end{itemize}

\note[item]{Moving on to the the final fascicle, which is the fascicle
on record types.}
\end{frame}

\begin{frame}
\frametitle{The record-type system}
\begin{itemize}
\item<1-> The \rnrs{7} has SRFI 9 \texttt{define-record-type}, a simple system
          for defining disjoint types
\item<1-> The \rnrs{6} included a featureful record type system
(single inheritance, procedural interface, inspection) that
      was criticized for its complexity
\item<2-> What do we do here?
  \begin{itemize}
    \item<3-> A simplified version of the \rnrs{6} record system?
              (SRFI 237 + 240)
    \item<4-> A non-compatible interface with a syntactic, procedural, and inspection interface?
              (SRFI 99/136/150)
    \item<5-> Just keep \rnrs{7}'s \texttt{define-record-type} as-is?
    \item<6-> ``The only record I expect [the Record-Winning Fascicle] to win is for how heated the discussion
will be.'' --- Daphne Preston-Kendal
  \end{itemize}
\end{itemize}

\note[item]<1>{The \rnrs{7} has a minimalistic record-type system, useful
for defining disjoint types. The \rnrs{6} in contrast has a very featureful
system that was criticized for its complexity and some of its design
choices, particularly regarding the interaction of the syntactic and
procedural layers.}

\note[item]<2>{So what do we do to reconcile this?}
\note[item]<3>{Should we use a simplified but compatible form of the
\rnrs{6} record system?}
\note[item]<4>{Should we use a non-compatible record system that has
some of the features?}
\note[item]<5>{Just keep SRFI 9 as-is?}
\note[item]<6>{Here's a great quote from Daphne Preston-Kendal:
``The only record I expect this to win is for how heated the discussion
will be.'' People care a lot about this, and we don't have a definitive
answer on what to do here yet.}
\end{frame}

\setbeamerfont{note page}{size=\footnotesize}
\begin{frame}[fragile]
\frametitle{SRFI 237: \rnrs{6} Records (refined)}
\begin{columns}
\begin{column}{0.50\textwidth}
\begin{itemize}
\item<1-> Previous \rnrs{6} code will work with this proposal
\item<1-> \texttt{define-record-type} can be made backwards-compatible
           with \rnrs{7} (SRFI 240)
\item<2-> Syntactic and procedural layers are compatible with each other
\item<3-> Syntactic layer can define multiple constructors
\item<4-> Certain record objects have datum representations
\end{itemize}
{\footnotesize Nieper-Wi\ss{}kirchen. ``SRFI 237: \rnrs{6} Records (refined).'' (2023)}
\end{column}
\begin{column}{0.50\textwidth}
\footnotesize
\begin{onlyenv}<2>
\begin{verbatim}
(define-record-type rec1
  (fields a)
  (protocol
   (lambda (p)
     (lambda (a/2)
       (p (* 2 a/2))))))
(define rec2
  (make-record-descriptor 'rec2
    rec1 #f #f #f
    '#((immutable b))
    (lambda (n)
      (lambda (a/2 b)
        ((n a/2) b)))))
(define-record-type rec3
  (parent rec2)
  (fields c)
  (protocol
   (lambda (n)
     (lambda (c)
       ((n c c) c)))))
\end{verbatim}
\end{onlyenv}
\begin{onlyenv}<3>
\begin{verbatim}
(define-record-type dictionary
  (nongenerative) (opaque #t)
  (fields ht)
  (protocol
   (lambda (p)
     (lambda args
       (assert #f)))))
(define-record-name
    (dictionary-from-hashtable
     dictionary)
  (protocol
   (lambda (p)
     (lambda (ht)
       (assert (hashtable? ht))
       (p ht)))))
\end{verbatim}
\end{onlyenv}
\begin{onlyenv}<4>
\begin{verbatim}
(define-record-type point
  (nongenerative point-1234)
  (fields x y))
(point? #r(point-1234 1.0 2.0))
; => #t
(point-x #r((point #f point-1234
             #f #f
             #((mutable x)
               (mutable y)))
            1.0 2.0)) ; => 1.0
\end{verbatim}
\end{onlyenv}
\end{column}
\end{columns}

\note[item]<1>{I will quickly go over the two major proposals that go beyond
the \rnrs{7}. The first is Marc Nieper-Wi\ss{}kirchen's proposal that is
backwards-compatible with the \rnrs{6} record system and the
\rnrs{7} record system.}

\note[item]<2>{This proposal makes the
syntactic and procedural layers compatible with each other: the
fact that they were not was a criticism of the \rnrs{6}.
On the right half, you can see that \texttt{rec1} is defined
syntactically, and \texttt{rec2} is defined with the procedural
interface and inherits from \texttt{rec1}. \texttt{Rec3} inherits
from \texttt{rec2} using the syntactic interface.}

\note[item]<3>{This proposal also makes the syntactic and procedural
layers equal by allowing the syntactic layer to define multiple
constructors for a single record type. Here you can see the
\texttt{dictionary} record type is defined so that one cannot construct
it directly, but it can be constructed with the
\texttt{dictionary-from-hashtable} constructor. Here
\texttt{dictionary} acts like a virtual class.}

\note[item]<4>{The proposal also adds datum representations for
non-generative, non-opaque records whose fields have Scheme data in
them. This allows for record types to be written and read. Displayed
are two different representations of a record object, where one is more
detailed than the other.}
\end{frame}
\setbeamerfont{note page}{size=\small}

\begin{frame}[fragile]
\frametitle{SRFI 99: ERR\textsuperscript{5}RS Records}
\begin{columns}
\begin{column}{0.50\textwidth}
\begin{itemize}
\item Alternative system with single inheritance
\item Procedural, syntactic, and inspection layers
\item No nongenerative, sealed, or opaque records
\end{itemize}
\end{column}
\begin{column}{0.50\textwidth}
\footnotesize
\begin{onlyenv}
\begin{verbatim}
(define-record-type rec1 #t #t a)
(define rec2
  (make-rtd 'rec2
            #((immutable b))
            rec1))
(define-record-type (rec3 rec2)
  #t #t c)
(define r (make-rec3 1 2 3))
(rec1-a r) ; => 1
((rtd-accessor rec2 'b) r) ; => 2
(rec3-c r) ; => 3
\end{verbatim}
\end{onlyenv}
\end{column}
\end{columns}

\note[item]{An alternative proposal is SRFI 99, written by Will
Clinger. It is a single-inheritance record type system that has a
procedural, syntactic, and inspection layer, like the \rnrs{6}.}

\note[item]{An example is shown on the right which is similar to the
first example on the previous slide. The first definition
makes a record with no parent using the syntactic interface.
The second creates a record type inheriting from the first using
the procedural interface, and the third has a record type defined with
the syntactic interface inheriting from the procedural interface.}

\note[item]{Note that this system does not have nongenerative, sealed,
or opaque records, and it does not have custom constructors like the
\rnrs{6}.}

\end{frame}

\begin{frame}
\frametitle{Other record-related matters}
\begin{itemize}
\item<2-> Tagged procedures
  \begin{itemize}
    \item<2-> MIT Scheme, CHICKEN, Gauche, Chibi, ...
    \item<2-> SRFI 259: Tagged procedures with type safety
  \end{itemize}
\item<3-> Custom ports
  \begin{itemize}
    \item<3-> \rnrs{6}-style ports, or something more advanced?
  \end{itemize}
\item<4-> Storage management (SRFI 254)
  \begin{itemize}
    \item<4-> Ephemerons (holders for weak values)
    \item<4-> Guardians (for cleanup of external resources)
    \item<4-> Transport cell guardians (for implementing e.g.
    \text{eq?}-based hash tables)
  \end{itemize}
\end{itemize}

\note[item]<1>{Outside of the big-ticket items, there are also some
matters that are relevant to containers of Scheme objects that we will
deal with here.}

\note[item]<2>{One of these is tagged procedures. These are procedures
that have data associated with them, where that data can be accessed
without invoking the procedure itself. This is useful when using
procedures as a part of an object system, where you want to know if
you can communicate with a procedure by passing a message before
actually passing that message.}

\note[item]<3>{We will also consider custom ports. Custom ports already
exist in the \rnrs{6}, although there are some ideas on extending this
system. The \rnrs{6} custom port system is unable to implement the
string and bytevector ports of the \rnrs{7}, for example. It would be
nice if the \rnrs{7}-Large's custom port system could handle that.}

\note[item]<4>{We will also consider some systems related to garbage
collection, such as supporting weakly held values and finalization.
One can read the proposal and the literature cited in it for more
information about these.}
\end{frame}

\begin{frame}
\frametitle{Volume II: Batteries}

\begin{columns}
\begin{column}{0.50\textwidth}
\begin{itemize}
\item<2-> {\color<3>{RedOrange} Lists (SRFI 1)}
\item<2-> {\color<4>{RedOrange} Character sets (SRFI 14)}
\item<2-> {\color<5>{RedOrange} \texttt{cut} (SRFI 26)}
\item<2-> {\color<5>{RedOrange} Stream (SRFI 41)}
\item<2-> {\color<4>{RedOrange} Boxes (SRFI 111)}
\item<2-> {\color<4>{RedOrange} Functional sets (SRFI 113)}
\item<2-> {\color<5>{RedOrange} Regex (SRFI 115)}
\item<2-> {\color<4>{RedOrange} Hash tables (SRFI 125)}
\item<2-> {\color<4>{RedOrange} Comparators (SRFI 128)}
\item<2-> {\color<3>{RedOrange} Sorting (SRFI 132)}
\item<2-> {\color<3>{RedOrange} Vectors (SRFI 133)}
\item<2-> {\color<4>{RedOrange} Immutable deques (SRFI 134)}
\end{itemize}
\end{column}
\begin{column}{0.50\textwidth}
\begin{itemize}
\item<2-> {\color<3>{RedOrange} Fixnums (SRFI 143)}
\item<2-> {\color<3>{RedOrange} Flonums (SRFI 144)}
\item<2-> {\color<3>{RedOrange} Bitwise (SRFI 151)}
\item<2-> {\color<3>{RedOrange} Strings (SRFI 152)}
\item<2-> {\color<4>{RedOrange} Functional ordered maps and hashmaps (SRFI 153)}
\item<2-> {\color<5>{RedOrange} Generators (SRFI 158)}
\item<2-> {\color<3>{RedOrange} Number vectors (SRFI 160)}
\item<2-> {\color<3>{RedOrange} Multiple values (SRFI 210)}
\item<2-> {\color<3>{RedOrange} Bytevectors (\rnrs{6})}
\item<2-> {\color<5>{RedOrange} Formatting (SRFI 159)}
\item<6-> May have error-raising requirements added to it
\end{itemize}
\end{column}
\end{columns}

\note[item]<1>{OK, that's all of the Foundations. It is quite a bit.
Next I will cover the ``Batteries,'' which is the much more well known
section of the \rnrs{7}-Large. This consists of things that can be
portably implemented in terms of the Foundations, and in many cases,
in terms of the \rnrs{6} or \rnrs{7}.}

\note[item]<2>{Here is the list of libraries that are currently voted
into the \rnrs{7}-Large. They are derived either from finalized SRFIs,
or from other Scheme standards.}

\note[item]<3>{This includes libraries that add operations to the
ones in the Foundations, such as libraries for lists, vectors, strings,
and new types such as number vectors and flonums,}

\note[item]<4>{common data structures such as hash tables and persistent
maps,}

\note[item]<5>{and other libraries, such as lazy streams and regular
expressions.}

\note[item]<6>{These proposals are mostly written with the \rnrs{7}
in mind. When we decide on the exception and condition system of the
\rnrs{7}-Large, we may extend requirements to raise exceptions on type
errors and other errors on the procedures in the Batteries.}
\end{frame}

\begin{frame}
\frametitle{Batteries: What else?}

\begin{itemize}
\item<2-> Bitvectors (SRFI 178)
\item<2-> Date and time manipulation
\item<2-> Multidimensional arrays (SRFI 231, 268)
\item<2-> Random number generation (SRFI 27, 194, 271)
\item<2-> JSON (SRFI 180)
\item<2-> Integer sets and maps (SRFI 217, 224)
\item<2-> Pipeline operators (SRFI 197)
\item<2-> Flexvectors (SRFI 214)
\item<2-> Argument parsing (SRFI 37)
\item<2-> A loop macro
\item<2-> A pattern matcher
\item<2-> \rnrs{6} compatibility libraries
\item<2-> more?
\end{itemize}

\note[item]<1>{So what other things are we thinking of adding to the
Batteries?}

\note[item]<2>{Here is a list of things, some with SRFIs, and some
without, that might make it in. Some of these are more likely than
others.}
\end{frame}

\begin{frame}
\frametitle{Volume III: Environments}

\begin{itemize}
\item<2-> File I/O (\rnrs{6} and \rnrs{7} libraries)
\item<2-> Basic filesystem operations (\texttt{delete-file}, \texttt{file-exists?})
\item<2-> Process context (\texttt{command-line}, \texttt{exit})
\item<3-> POSIX API (filesystem, termios, pipes, process control, signals, etc...)
\item<4-> C FFI
  \begin{itemize}
    \item<4-> Prior art: \texttt{pffi} and \texttt{foreign-c}
  \end{itemize}
\item<5-> Sockets, TLS, HTTP, and the modern networking kitchen sink
\end{itemize}

\note[item]<1>{The final volume of the \rnrs{7}-Large will be the
Environments, a set of optional standard libraries for interacting with
the operating environment.}

\note[item]<2>{The environments will contain the procedures for
opening files, closing files, and operating on the
process that existed in the \rnrs{6} and \rnrs{7}.}

\note[item]<3>{Another thing we might want to add is a standard interface
to the POSIX API. Then we can extend our file I/O operations to operations
on the filesystem, the terminal, pipes, and everything one could need
(on POSIX).}

\note[item]<4>{Another good thing to have would be a standard C FFI.
As it turns out, figuring out a good set of FFI operations for
implementations to support is difficult. For example, some implementations
currently do not support calling Scheme callbacks from C code. There
have been some attempts at making a standard FFI, such as Takahashi Kato's
\rnrs{6} \texttt{pffi}, and Retropikzel's \texttt{foreign-c} for \rnrs{7}.}

\note[item]<5>{And a final thing to consider for all of this business is
the wild world of networking, including sockets, TLS, and more. These are
very important for modern programs that involve big servers and clients
talking to those servers.}
\end{frame}

\begin{frame}
\frametitle{Conclusion}

\begin{itemize}
\item Volume I (Foundations): Required features, not portably implementable
  \begin{itemize}
    \item Macro system
    \item Extended lexical syntax
    \item Delimited continuations
    \item Record type system
  \end{itemize}
\item Volume II (Batteries): Required features, portably implementable in terms
      of Volume I
  \begin{itemize}
    \item Utilities for data types
    \item Data structures and containers
  \end{itemize}
\item Volume III (Environments): Optional features, not portably implementable
  \begin{itemize}
    \item Foreign function interface
    \item Operating system interface
  \end{itemize}
\end{itemize}

\note[item]{That covers the \rnrs{7}-Large, as we have currently
planned it out. We are starting with required and non-portable
features, before integrating the required and portable features,
and then specifying the optional and non-portable features.}

\note[item]{The first volume will encompass macro systems, more
lexical syntax, delimited continuations, and the record type system.}

\note[item]{The second volume will encompass utilities and data
structures defined for the things in the first volume.}

\note[item]{The third volume will encompass interfaces to outside
systems, like foreign function interfaces and the operating system.}

\end{frame}

\begin{frame}
\frametitle{Acknowledgements}

\begin{columns}
\begin{column}{0.5\textwidth}
\textbf{Working Group 2}
\begin{itemize}
\item Alaric Snell-Pym
\item Arthur A. Gleckler
%\item Daphne Preston-Kendal
\item Jani Juhani Sinervo
\item John Cowan
\item Marc Nieper-Wißkirchen
\item Peter McGoron
\item Sudarshan S Chawathe
\item Vincent Manis
\item Wolfgang Corcoran-Mathe
\item Zhu Zihao
\item ``Identity''
\end{itemize}
\end{column}
\begin{column}{0.5\textwidth}
And the contributors to many SRFIs:
\begin{itemize}
\item Alex Shinn
\item Daphne Preston-Kendal
\item Marc Feeley
\item Olin Shivers
\item Philip Bewig
\item Sebastian Egner
\item Shiro Kawai
\item Taylor Campbell
\item Will Clinger
\item ... and many more!
\end{itemize}
\end{column}
\end{columns}

\note[item]{I'd like to end the talk by thanking the members of Working
Group 2, who have spent a lot of time discussing things and writing
proposals for this project.
I want to thank all of them for their effort in working
on making \rnrs{7}-Large a reality by coming to meetings in the odd hours
of their respective timezones. We would not be making the progress we are
making now if it were not for them.}

\note[item]{I also want to thank the contributors to the SRFIs that are
going into the \rnrs{7}-Large. This is only a fraction of the people who
have contributed, as many people have discussed them on the mailing lists.}
\end{frame}

\end{document}