#lang scribble/doc
@(require scribble/manual
          (for-syntax scheme/base)
          (for-label scheme/base))

@(define-syntax (srfi stx)
  (syntax-case stx ()
   [(_ num #:subdir subdir? . title)
    (with-syntax ([srfi/n (string->symbol (format "srfi/~a" (syntax-e #'num)))])
      #'(begin
          (section #:tag (format "srfi-~a" num)
                   #:style 'unnumbered
                   (format "SRFI ~a: " num)
                   . title)
          (defmodule srfi/n)
          "Original specification: "
          @link[(if subdir?
                  (format "../srfi-std/srfi-~a/srfi-~a.html" num num)
                  (format "../srfi-std/srfi-~a.html" num))
                "SRFI "
                (number->string num)]))]
   [(_ num . title) #'(srfi num #:subdir #f . title)]))

@;{ The `lst' argument is a list of
       (list sym syntactic-form? html-anchor) }
@(define (redirect n lst #:subdir [subdir? #f])
   (let ([file (if subdir?
                 (format "srfi-~a/srfi-~a.html" n n)
                 (format "srfi-~a.html" n))]
         [mod-path (string->symbol (format "srfi/~a" n))])
     (make-binding-redirect-elements mod-path
       (map (lambda (b)
              (list (car b) (cadr b)
                    (build-path 'up "srfi-std" file)
                    (caddr b)))
            lst))))

@(define in-core
   (case-lambda
     [() (in-core ".")]
     [(k) @elem{This SRFI's bindings are also available in
                @schememodname[scheme/base]@|k|}]))

@(begin
  (define-syntax-rule (def-mz mz-if)
    (begin
      (require (for-label mzscheme))
      (define mz-if (scheme if))))
  (def-mz mz-if))

@; ----------------------------------------------------------------------

@title{@bold{SRFIs}: Libraries}

The @link["http://srfi.schemers.org/"]{Scheme Requests for
Implementation} (a.k.a. @deftech{SRFI}) process allows individual
members of the Scheme community to propose libraries and extensions to
be supported by multiple Scheme implementations.

PLT Scheme is distributed with implementations of many SRFIs, most of
which can be implemented as libraries. To import the bindings of SRFI
@math{n}, use

@schemeblock[
(require @#,elem{@schemeidfont{srfi/}@math{n}})
]

This document lists the SRFIs that are supported by PLT Scheme and
provides a link to the original SRFI specification (which is also
distributed as part of PLT Scheme's documentation).

@table-of-contents[]

@; ----------------------------------------

@srfi[1]{List Library}

This SRFI works with pairs and lists as in @schememodname[scheme] and
@schememodname[mzscheme], which are immutable, so it does not export
@schemeidfont{set-car!} and @schemeidfont{set-cdr!}. The other
provided bindings that end in @schemeidfont{!} are equivalent to the
corresponding bindings without @schemeidfont{!}.

@redirect[1 '(
 (cons #f "cons")
 (list #f "list")
 (xcons #f "xcons")
 (cons* #f "cons*")
 (make-list #f "make-list")
 (list-tabulate #f "list-tabulate")
 (list-copy #f "list-copy")
 (circular-list #f "circular-list")
 (iota #f "iota")
 (pair? #f "pair-p")
 (null? #f "null-p")
 (proper-list? #f "proper-list-p")
 (circular-list? #f "circular-list-p")
 (dotted-list? #f "dotted-list-p")
 (not-pair? #f "not-pair-p")
 (null-list? #f "null-list-p")
 (car #f "car")
 (cdr #f "cdr")
 (cddadr #f "cddadr")
 (cddddr #f "cddddr")
 (list-ref #f "list-ref")
 (first #f "first")
 (second #f "second")
 (third #f "third")
 (fourth #f "fourth")
 (fifth #f "fifth")
 (sixth #f "sixth")
 (seventh #f "seventh")
 (eighth #f "eighth")
 (ninth #f "ninth")
 (tenth #f "tenth")
 (car+cdr #f "car+cdr")
 (take #f "take")
 (drop #f "drop")
 (take-right #f "take-right")
 (drop-right #f "drop-right")
 (take! #f "take!")
 (drop-right! #f "drop-right!")
 (split-at #f "split-at")
 (split-at! #f "split-at!")
 (last #f "last")
 (last-pair #f "last-pair")
 (length #f "length")
 (length+ #f "length+")
 (append #f "append")
 (append! #f "append!")
 (concatenate #f "concatenate")
 (concatenate! #f "concatenate!")
 (reverse #f "reverse")
 (reverse! #f "srfi-1.html")
 (append-reverse #f "append-reverse")
 (append-reverse! #f "append-reverse!")
 (zip #f "zip")
 (unzip1 #f "unzip1")
 (unzip2 #f "unzip2")
 (unzip3 #f "unzip3")
 (unzip4 #f "unzip4")
 (unzip5 #f "unzip5")
 (count #f "count")
 (fold #f "fold")
 (fold-right #f "fold-right")
 (pair-fold #f "pair-fold")
 (pair-fold-right #f "pair-fold-right")
 (reduce #f "reduce")
 (reduce-right #f "reduce-right")
 (unfold #f "unfold")
 (map #f "map")
 (for-each #f "srfi-1.html")
 (append-map #f "append-map")
 (append-map! #f "append-map!")
 (map! #f "map!")
 (map-in-order #f "map-in-order")
 (pair-for-each #f "pair-for-each")
 (filter-map #f "filter-map")
 (filter #f "filter")
 (filter! #f "filter!")
 (partition! #f "partition!")
 (remove! #f "remove!")
 (remove #f "remove")
 (partition #f "partition")
 (find #f "find")
 (find-tail #f "find-tail")
 (take-while #f "take-while")
 (take-while! #f "take-while!")
 (drop-while #f "drop-while")
 (span #f "span")
 (span! #f "span!")
 (break #f "break")
 (break! #f "break!")
 (any #f "any")
 (every #f "every")
 (list-index #f "list-index")
 (member #f "member")
 (memq #f "memq")
 (memv #f "memv")
 (delete #f "delete")
 (delete-duplicates #f "delete-duplicates")
 (delete! #f "delete!")
 (delete-duplicates! #f "delete-duplicates!")
 (assoc #f "assoc")
 (assq #f "assq")
 (assv #f "assv")
 (alist-cons #f "alist-cons")
 (alist-copy #f "alist-copy")
 (alist-delete #f "alist-delete")
 (alist-delete! #f "alist-delete!")
 (lset #f "lset")
 (lset= #f "lset=")
 (lset-adjoin #f "lset-adjoin")
 (lset-union #f "lset-union")
 (lset-intersection #f "lset-intersection")
 (lset-intersection! #f "lset-intersection!")
 (lset-union! #f "lset-union!")
 (lset-difference! #f "lset-difference!")
 (lset-xor! #f "lset-xor!")
 (lset-diff+intersection! #f "lset-diff+intersection!")
 (lset-difference #f "lset-difference")
 (lset-xor #f "lset-xor")
 (lset-diff+intersection #f "lset-diff+intersection")
)]

@; ----------------------------------------

@srfi[2]{AND-LET*: an AND with local bindings...}

@redirect[2 '(
 (and-let* #t "and-let")
)]

@; ----------------------------------------

@srfi[4]{Homogeneous numeric vector datatypes}

@redirect[4 '(
 (s8vector #f "s8vector")
 (u8vector #f "s8vector")
 (s16vector #f "s8vector")
 (u16vector #f "u8vector")
 (s32vector #f "s16vector")
 (u32vector #f "u16vector")
 (s64vector #f "s64vector")
 (u64vector #f "u64vector")
 (f32vector #f "f32vector")
 (f64vector #f "f64vector")
)]

This SRFI's reader and printer syntax is not supported. The bindings
are also available from @schememodname[scheme/foreign].

@; ----------------------------------------

@srfi[5]{A compatible let form with signatures and rest arguments}

@redirect[5 '(
 (let #t "unnamed")
)]

@; ----------------------------------------

@srfi[6]{Basic String Ports}

@redirect[6 '(
 (open-input-string #f "open-input-string")
 (open-output-string #f "open-output-string")
 (get-output-string #f "get-output-string")
)]

@in-core{}

@; ----------------------------------------

@srfi[7]{Feature-based program configuration language}

@redirect[7 '(
 (program #t "program")
)]

@; ----------------------------------------

@srfi[8]{RECEIVE: Binding to multiple values}

@redirect[8 '(
 (receive #t "receive")
)]

@; ----------------------------------------

@srfi[9]{Defining Record Types}

@redirect[9 '(
 (define-record-type #t "define-record-type")
)]

@; ----------------------------------------

@srfi[11]{Syntax for receiving multiple values}

@redirect[11 '(
 (let-values #t "let-values")
 (let*-values #t "let*-values")
)]

@in-core{, but without support for dotted ``rest'' bindings.}

@; ----------------------------------------

@srfi[13]{String Libraries}

@redirect[13 '(
 (string? #f "string-p")
 (string-null? #f "string-null-p")
 (string-every #f "string-every")
 (string-any #f "string-any")
 (make-string #f "make-string")
 (string #f "string")
 (string-tabulate #f "string-tabulate")
 (string->list #f "string2list")
 (list->string #f "list2string")
 (reverse-list->string #f "reverse-list2string")
 (string-join #f "string-join")
 (string-length #f "string-length")
 (string-ref #f "string-ref")
 (string-copy #f "string-copy")
 (substring/shared #f "substring/shared")
 (string-copy! #f "string-copy!")
 (string-take #f "string-take")
 (string-drop #f "string-drop")
 (string-take-right #f "string-take-right")
 (string-drop-right #f "string-drop-right")
 (string-pad #f "string-pad")
 (string-pad-right #f "string-pad-right")
 (string-trim #f "string-trim")
 (string-trim-right #f "string-trim-right")
 (string-trim-both #f "string-trim-both")
 (string-set! #f "string-set!")
 (string-fill! #f "string-fill!")
 (string-compare #f "string-compare")
 (string-compare-ci #f "string-compare-ci")
 (string= #f "string=")
 (string<> #f "string<>")
 (string< #f "string<")
 (string> #f "string>")
 (string<= #f "string<=")
 (string>= #f "string>=")
 (string-ci= #f "string-ci=")
 (string-ci<> #f "string-ci<>")
 (string-ci< #f "string-ci<")
 (string-ci> #f "string-ci>")
 (string-ci<= #f "string-ci<=")
 (string-ci>= #f "string-ci>=")
 (string-hash #f "string-hash")
 (string-hash-ci #f "string-hash-ci")
 (string-prefix-length #f "string-prefix-length")
 (string-suffix-length #f "string-suffix-length")
 (string-prefix-length-ci #f "string-prefix-length-ci")
 (string-suffix-length-ci #f "string-suffix-length-ci")
 (string-prefix? #f "string-prefix-p")
 (string-suffix? #f "string-suffix-p")
 (string-prefix-ci? #f "string-prefix-ci-p")
 (string-suffix-ci? #f "string-suffix-ci-p")
 (string-index #f "string-index")
 (string-index-right #f "string-index-right")
 (string-skip #f "string-skip")
 (string-skip-right #f "string-skip-right")
 (string-count #f "string-count")
 (string-contains #f "string-contains")
 (string-contains-ci #f "string-contains-ci")
 (string-titlecase #f "string-titlecase")
 (string-titlecase! #f "string-titlecase!")
 (string-upcase #f "string-upcase")
 (string-upcase! #f "string-upcase!")
 (string-downcase #f "string-downcase")
 (string-downcase! #f "string-downcase!")
 (string-reverse #f "string-reverse")
 (string-reverse! #f "string-reverse!")
 (string-append #f "string-append")
 (string-concatenate #f "string-concatenate")
 (string-concatenate/shared #f "string-concatenate/shared")
 (string-append/shared #f "string-append/shared")
 (string-concatenate-reverse #f "string-concatenate-reverse")
 (string-concatenate-reverse/shared #f "string-concatenate-reverse/shared")
 (string-map #f "string-map")
 (string-map! #f "string-map!")
 (string-fold #f "string-fold")
 (string-fold-right #f "string-fold-right")
 (string-unfold #f "string-unfold")
 (string-unfold-right #f "string-unfold-right")
 (string-for-each #f "string-for-each")
 (string-for-each-index #f "string-for-each-index")
 (xsubstring #f "xsubstring")
 (string-xcopy! #f "string-xcopy!")
 (string-replace #f "string-replace")
 (string-tokenize #f "string-tokenize")
 (string-filter #f "string-filter")
 (string-delete #f "string-delete")
 (string-parse-start+end #f "string-parse-start+end")
 (string-parse-final-start+end #f "string-parse-final-start+end")
 (let-string-start+end #f "let-string-start+end")
 (check-substring-spec #f "check-substring-spec")
 (substring-spec-ok? #f "substring-spec-ok-p")
 (make-kmp-restart-vector #f "make-kmp-restart-vector")
 (kmp-step #f "kmp-step")
 (string-kmp-partial-search #f "string-kmp-partial-search")
)]

@; ----------------------------------------

@srfi[14]{Character-set Library}

@redirect[14 '(
 (char-set? #f "char-set-p")
 (char-set= #f "char-set=")
 (char-set<= #f "char-set<=")
 (char-set-hash #f "char-set-hash")
 (char-set-cursor #f "char-set-cursor")
 (char-set-ref #f "char-set-ref")
 (char-set-cursor-next #f "char-set-cursor-next")
 (end-of-char-set? #f "end-of-char-set-p")
 (char-set-fold #f "char-set-fold")
 (char-set-unfold #f "char-set-unfold")
 (char-set-unfold! #f "char-set-unfold!")
 (char-set-for-each #f "char-set-for-each")
 (char-set-map #f "char-set-map")
 (char-set-copy #f "char-set-copy")
 (char-set #f "char-set")
 (list->char-set #f "list->char-set")
 (list->char-set! #f "list->char-set!")
 (string->char-set #f "string->char-set")
 (string->char-set! #f "string->char-set!")
 (char-set-filter #f "char-set-filter")
 (char-set-filter! #f "char-set-filter!")
 (ucs-range->char-set #f "ucs-range->char-set")
 (ucs-range->char-set! #f "ucs-range->char-set!")
 (->char-set #f "->char-set")
 (char-set->list #f "char-set->list")
 (char-set->string #f "char-set->string")
 (char-set-size #f "char-set-size")
 (char-set-count #f "char-set-count")
 (char-set-every #f "char-set-every")
 (char-set-any #f "char-set-any")
 (char-set-contains? #f "char-set-contains-p")
 (char-set-adjoin #f "char-set-adjoin")
 (char-set-delete #f "char-set-delete")
 (char-set-adjoin! #f "char-set-adjoin!")
 (char-set-delete! #f "char-set-delete!")
 (char-set-complement #f "char-set-complement")
 (char-set-union #f "char-set-union")
 (char-set-intersection #f "char-set-intersection")
 (char-set-difference #f "char-set-difference")
 (char-set-xor #f "char-set-xor")
 (char-set-diff+intersection #f "char-set-diff+intersection")
 (char-set-complement! #f "char-set-complement!")
 (char-set-union! #f "char-set-union!")
 (char-set-intersection! #f "char-set-intersection!")
 (char-set-difference! #f "char-set-difference!")
 (char-set-xor! #f "char-set-xor!")
 (char-set-diff+intersection! #f "char-set-diff+intersection!")
 (char-set:lower-case #f "char-set:lower-case")
 (char-set:upper-case #f "char-set:upper-case")
 (char-set:title-case #f "char-set:title-case")
 (char-set:letter #f "char-set:letter")
 (char-set:digit #f "char-set:digit")
 (char-set:letter+digit #f "char-set:letter+digit")
 (char-set:graphic #f "char-set:graphic")
 (char-set:printing #f "char-set:printing")
 (char-set:whitespace #f "char-set:whitespace")
 (char-set:iso-control #f "char-set:iso-control")
 (char-set:punctuation #f "char-set:punctuation")
 (char-set:symbol #f "char-set:symbol")
 (char-set:hex-digit #f "char-set:hex-digit")
 (char-set:blank #f "char-set:blank")
 (char-set:ascii #f "char-set:ascii")
 (char-set:empty #f "char-set:empty")
 (char-set:full #f "char-set:full")
)]

@; ----------------------------------------

@srfi[16]{Syntax for procedures of variable arity}

@redirect[16 '(
 (case-lambda #t "case-lambda")
)]

@in-core{}

@; ----------------------------------------

@srfi[17]{Generalized set!}

@redirect[17 '(
 (set! #t "set!")
 (getter-with-setter #f "getter-with-setter")
)]

@; ----------------------------------------

@srfi[19]{Time Data Types and Procedures}

@redirect[19 '(
 (time-duration #f "")
 (time-monotonic #f "time-monotonic")
 (time-process #f "time-process")
 (time-tai #f "time-tai")
 (time-thread #f "time-thread")
 (time-utc #f "time-utc")
 (current-date #f "")
 (current-julian-day #f "current-julian-day")
 (current-modified-julian-day #f "current-modified-julian-day")
 (current-time #f "current-time")
 (time-resolution #f "time-resolution")
 (make-time #f "make-time")
 (time? #f "time-p")
 (time-type #f "time-type")
 (time-nanosecond #f "time-nanosecond")
 (time-second #f "time-second")
 (set-time-type! #f "set-time-type!")
 (set-time-nanosecond! #f "set-time-nanosecond!")
 (set-time-second! #f "set-time-second!")
 (copy-time #f "copy-time")
 (time<=? #f "time<=-p")
 (time<? #f "time<-p")
 (time=? #f "time=-p")
 (time>=? #f "time>=-p")
 (time>? #f "time>-p")
 (time-difference #f "time-difference")
 (time-difference! #f "time-difference!")
 (add-duration #f "add-duration")
 (add-duration! #f "add-duration!")
 (subtract-duration #f "subtract-duration")
 (subtract-duration! #f "subtract-duration!")
 (make-date #f "make-date")
 (date? #f "date-p")
 (date-nanosecond #f "date-nanosecond")
 (date-second #f "date-second")
 (date-minute #f "date-minute")
 (date-hour #f "date-hour")
 (date-day #f "date-day")
 (date-month #f "date-month")
 (date-year #f "date-year")
 (date-zone-offset #f "date-zone-offset")
 (date-year-day #f "date-year-day")
 (date-week-day #f "date-week-day")
 (date-week-number #f "date-week-number")
 (date->julian-day #f "date->julian-day")
 (date->modified-julian-day #f "date->modified-julian-day")
 (date->time-monotonic #f "date->time-monotonic")
 (date->time-tai #f "date->time-tai")
 (date->time-utc #f "date->time-utc")
 (julian-day->date #f "julian-day->date")
 (julian-day->time-monotonic #f "julian-day->time-monotonic")
 (julian-day->time-tai #f "julian-day->time-tai")
 (julian-day->time-utc #f "julian-day->time-utc")
 (modified-julian-day->date #f "modified-julian-day->date")
 (modified-julian-day->time-monotonic #f "modified-julian-day->time-monotonic")
 (modified-julian-day->time-tai #f "modified-julian-day->time-tai")
 (modified-julian-day->time-utc #f "modified-julian-day->time-utc")
 (time-monotonic->date #f "time-monotonic->date")
 (time-monotonic->julian-day #f "time-monotonic->julian-day")
 (time-monotonic->modified-julian-day #f "time-monotonic->modified-julian-day")
 (time-monotonic->time-tai #f "time-monotonic->time-tai")
 (time-monotonic->time-tai! #f "time-monotonic->time-tai!")
 (time-monotonic->time-utc #f "time-monotonic->time-utc")
 (time-monotonic->time-utc! #f "time-monotonic->time-utc!")
 (time-tai->date #f "time-tai->date")
 (time-tai->julian-day #f "time-tai->julian-day")
 (time-tai->modified-julian-day #f "time-tai->modified-julian-day")
 (time-tai->time-monotonic #f "time-tai->time-monotonic")
 (time-tai->time-monotonic! #f "time-tai->time-monotonic!")
 (time-tai->time-utc #f "time-tai->time-utc")
 (time-tai->time-utc! #f "time-tai->time-utc!")
 (time-utc->date #f "time-utc->date")
 (time-utc->julian-day #f "time-utc->julian-day")
 (time-utc->modified-julian-day #f "time-utc->modified-julian-day")
 (time-utc->time-monotonic #f "time-utc->time-monotonic")
 (time-utc->time-monotonic! #f "time-utc->time-monotonic!")
 (time-utc->time-tai #f "time-utc->time-tai")
 (time-utc->time-tai! #f "time-utc->time-tai!")
 (date->string #f "date->string")
 (string->date #f "string->date")
)]

Care most be taken NOT to confuse the internal date structure with the
PLT Scheme @scheme[date]; they are not the same, and all procedures
from the SRFI library expect the former.

@; ----------------------------------------

@srfi[23]{Error reporting mechanism}

@redirect[23 '(
 (error #f "error")
)]

@in-core{}

@; ----------------------------------------

@srfi[25]{Multi-dimensional Array Primitives}

@redirect[25 '(
 (array? #f "array-p")
 (make-array #f "make-array")
 (shape #f "shape")
 (array #f "array")
 (array-rank #f "array-rank")
 (array-start #f "array-start")
 (array-end #f "array-end")
 (array-ref #f "array-ref")
 (array-set! #f "array-set!")
 (share-array #f "share-array")
)]

@; ----------------------------------------

@srfi[26]{Notation for Specializing Parameters without Currying}

@redirect[26 '(
 (cut #t "cut")
 (cute #t "cute")
)]


@; ----------------------------------------

@srfi[27]{Sources of Random Bits}

@redirect[27 '(
 (random-integer #f "random-integer")
 (random-real #f "random-real")
 (default-random-source #f "default-random-source")
 (make-random-source #f "make-random-source")
 (random-source? #f "random-source-p")
 (random-source-state-ref #f "random-source-state-ref")
 (random-source-state-ref! #f "random-source-state-ref")
 (random-source-randomize! #f "random-source-randomize!")
 (random-source-pseudo-randomize! #f "random-source-pseudo-randomize!")
 (random-source-make-integers #f "random-source-make-integers")
 (random-source-make-reals #f "random-source-make-reals")
)]

@; ----------------------------------------

@srfi[28]{Basic Format Strings}

@redirect[28 '(
 (format #f "format")
)]

@in-core{}

@; ----------------------------------------

@srfi[29]{Localization}

@redirect[29 '(
 (current-language #f "current-language")
 (current-country #f "current-country")
 (current-locale-details #f "current-locale-details")
 (declare-bundle! #f "declare-bundle!")
 (store-bundle #f "store-bundle")
 (load-bundle! #f "load-bundle!")
 (localized-template #f "localized-template")
)]

@; ----------------------------------------

@srfi[30]{Nested Multi-line Comments}

This SRFI's syntax is part of PLT Scheme's default reader.

@; ----------------------------------------

@srfi[31]{A special form rec for recursive evaluation}

@redirect[31 '(
 (rec #t "rec")
)]

@; ----------------------------------------

@srfi[34]{Exception Handling for Programs}

@redirect[34 '(
 (with-exception-handler #f "with-exception-handler")
 (guard #t "guard")
 (raise #f "raise")
)]

@; ----------------------------------------

@srfi[35]{Conditions}

@; ----------------------------------------

@srfi[38]{External Representation for Data With Shared Structure}

@redirect[38 '(
 (write-with-shared-structure #f "write-with-shared-structure")
 (read-with-shared-structure #f "read-with-shared-structure")
)]

This SRFI's syntax is part of PLT Scheme's default reader and printer.

@; ----------------------------------------

@srfi[39]{Parameter objects}

@redirect[39 '(
 (make-parameter #f "make-parameter")
 (parameterize #t "parameterize")
)]

@in-core{}

@; ----------------------------------------

@srfi[40]{A Library of Streams}

@redirect[40 '(
 (stream-cons #t "stream-cons")
 (stream? #f "stream?")
 (stream-null? #f "stream-null?")
 (stream-car #f "stream-car")
 (stream-cdr #f "stream-cdr")
 (stream-delay #t "stream-delay")
 (stream-null #f "stream-null")
 (stream #f "stream")
 (stream-unfoldn #f "stream-unfoldn")
 (stream-map #f "stream-map")
 (stream-for-each #f "stream-for-each")
 (stream-filter #f "stream-filter")
)]

Superceded by @schememodname[srfi/41].

@; ----------------------------------------

@srfi[41 #:subdir #t]{Streams}

@redirect[41 #:subdir #t '(
 (stream-null #f "stream-null")
 (stream-cons #t "stream-cons")
 (stream? #f "stream?")
 (stream-null? #f "stream-null?")
 (stream-pair? #f "stream-pair?")
 (stream-car #f "stream-car")
 (stream-cdr #f "stream-cdr")
 (stream-lambda #t "stream-lambda")
 (define-stream #t "define-stream")
 (list->stream #f "list-to-stream")
 (port->stream #f "port-to-stream")
 (stream #t "stream")
 (stream->list #f "stream-to-list")
 (stream-append #f "stream-append")
 (stream-concat #f "stream-concat")
 (stream-constant #f "stream-constant")
 (stream-drop #f "stream-drop")
 (stream-drop-while #f "stream-drop-while")
 (stream-filter #f "stream-filter")
 (stream-fold #f "stream-fold")
 (stream-for-each #f "stream-for-each")
 (stream-from #f "stream-from")
 (stream-iterate #f "stream-iterate")
 (stream-length #f "stream-length")
 (stream-let #t "stream-let")
 (stream-map #f "stream-map")
 (stream-match #t "stream-match")
 (stream-of #t "stream-of")
 (stream-range #f "stream-range")
 (stream-ref #f "stream-ref")
 (stream-reverse #f "stream-reverse")
 (stream-scan #f "stream-scan")
 (stream-take #f "stream-take")
 (stream-take-while #f "stream-take-while")
 (stream-unfold #f "stream-unfold")
 (stream-zip #f "stream-zip")
)]

@; ----------------------------------------

@srfi[42]{Eager Comprehensions}

@redirect[42 '(
 (do-ec #t "do-ec")
 (list-ec #t "list-ec")
 (append-ec #t "append-ec")
 (string-ec #t "string-ec")
 (string-append-ec #t "string-append-ec")
 (vector-ec #t "vector-ec")
 (vector-of-length-ec #t "vector-of-length-ec")
 (sum-ec #t "sum-ec")
 (product-ec #t "product-ec")
 (min-ec #t "min-ec")
 (max-ec #t "max-ec")
 (any?-ec #t "any?-ec")
 (every?-ec #t "every?-ec")
 (first-ec #t "first-ec")
 (last-ec #t "last-ec")
 (fold-ec #t "fold-ec")
 (fold3-ec #t "fold3-ec")
 (generator #t "generator")
 (if #t "if")
 (not #t "not")
 (and #t "and")
 (or #t "or")
 (begin #t "begin")
 (nested #t "nested")
 (: #t ":")
 (:list #t ":list")
 (:string #t ":string")
 (:vector #t ":vector")
 (:integers #t ":integers")
 (:range #t ":range")
 (:real-range #t ":real-range")
 (:char-range #t ":char-range")
 (:port #t ":port")
 (:dispatched #t "")
 (:generator-proc #t ":generator-proc")
 (:do #t ":do")
 (:let #t ":let")
 (:parallel #t ":parallel")
 (:while #t ":while")
 (:until #t ":until")
)]

Forms that syntactically detect @scheme[if] recognize both @scheme[if]
from @schememodname[scheme/base] and @mz-if from
@schememodname[mzscheme].

@; ----------------------------------------

@srfi[43]{Vector Library}

@redirect[43 '(
 (make-vector #f "make-vector")
 (vector #f "vector")
 (vector-unfold #f "vector-unfold")
 (vector-unfold-right #f "vector-unfold-right")
 (vector-copy #f "vector-copy")
 (vector-reverse-copy #f "vector-reverse-copy")
 (vector-append #f "vector-append")
 (vector-concatenate #f "vector-concatenate")
 (vector? #f "vector-p")
 (vector-empty? #f "vector-empty?")
 (vector= #f "vector-eq")
 (vector-ref #f "vector-ref")
 (vector-length #f "vector-length")
 (vector-fold #f "vector-fold")
 (vector-fold-right #f "vector-fold-right")
 (vector-map #f "vector-map")
 (vector-map! #f "vector-map-bang")
 (vector-for-each #f "vector-for-each")
 (vector-count #f "vector-count")
 (vector-index #f "vector-index")
 (vector-index-right #f "vector-index-right")
 (vector-skip #f "vector-skip")
 (vector-skip-right #f "vector-skip-right")
 (vector-binary-search #f "vector-binary-search")
 (vector-any #f "vector-any")
 (vector-every #f "vector-every")
 (vector-set! #f "vector-set-bang")
 (vector-swap! #f "vector-swap-bang")
 (vector-fill! #f "vector-fill-bang")
 (vector-reverse! #f "vector-reverse-bang")
 (vector-copy! #f "vector-copy-bang")
 (vector-reverse-copy! #f "vector-reverse-copy-bang")
 (vector->list #f "vector->list")
 (reverse-vector->list #f "reverse-vector->list")
 (list->vector #f "list->vector")
 (reverse-list->vector #f "reverse-list->vector")
)]

@; ----------------------------------------

@srfi[45]{Primitives for Expressing Iterative Lazy Algorithms}

@redirect[45 '(
 (delay #t "delay")
 (lazy #t "lazy")
 (force #f "force")
 (eager #f "eager")
)]

Additional binding:

@defproc[(promise? [v any/c]) boolean?]{
Returns @scheme[#t] if @scheme[v] is a promise, @scheme[#f] otherwise.}

@; ----------------------------------------

@srfi[48]{Intermediate Format Strings}

@redirect[48 '(
 (format #f "format")
)]

@; ----------------------------------------

@srfi[54]{Formatting}

@; ----------------------------------------

@srfi[57]{Records}

@; ----------------------------------------

@srfi[59]{Vicinity}

@redirect[59 '(
 (program-vicinity #f "program-vicinity")
 (library-vicinity #f "library-vicinity")
 (implementation-vicinity #f "implementation-vicinity")
 (user-vicinity #f "user-vicinity")
 (home-vicinity #f "home-vicinity")
 (in-vicinity #f "in-vicinity")
 (sub-vicinity #f "sub-vicinity")
 (make-vicinity #f "make-vicinity")
 (pathname->vicinity #f "pathname-to-vicinity")
 (vicinity:suffix? #f "vicinity:suffix-p")
)]

@; ----------------------------------------

@srfi[60]{Integers as Bits}

@; ----------------------------------------

@srfi[61]{A more general cond clause}

@; ----------------------------------------

@; no actual library for this
@section[#:tag "srfi-62" #:style 'unnumbered]{SRFI 62: S-expression comments}

Original specification: @link["../srfi-std/srfi-62.html"]{SRFI 62}

This SRFI's syntax is part of PLT Scheme's default reader (no
@scheme[require] is needed).

@; ----------------------------------------

@srfi[63]{Homogeneous and Heterogeneous Arrays}

@; ----------------------------------------

@srfi[64]{A Scheme API for test suites}

@; ----------------------------------------

@srfi[66]{Octet Vectors}

@; ----------------------------------------

@srfi[67 #:subdir #t]{Compare Procedures}

@; ----------------------------------------

@srfi[69]{Basic hash tables}

@; ----------------------------------------

@srfi[71]{Extended LET-syntax for multiple values}

@; ----------------------------------------

@srfi[74]{Octet-Addressed Binary Blocks}

@; ----------------------------------------

@srfi[78]{Lightweight testing}

@; ----------------------------------------

@srfi[86]{MU & NU simulating VALUES & CALL-WITH-VALUES...}

@; ----------------------------------------

@srfi[87]{=> in case clauses}

@; ----------------------------------------

@srfi[98]{An interface to access environment variables}

@redirect[98 '((get-environment-variable #f "get-environment-variable")
               (get-environment-variables #f "get-environment-variables"))]

@; ----------------------------------------

@index-section[]