suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Scribble: change the way `racketblock' etc. indent/inset works

Browse Source 
- introduce 'code-inset style for nested blocks
 - use style instead of spaces for code indentation
 - sigplanconf adds vertical space around 'code-inset
 - more ...0 variants to compose better
This commit is contained in:
Matthew Flatt 2011-03-30 12:57:10 -06:00
parent 8a283650c4
commit bbc5533938
14 changed files with 255 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

228
collects/scribble/eval.rkt
View File

@ -13,9 +13,11 @@
(for-syntax racket/base))
(provide interaction
interaction0
interaction-eval
interaction-eval-show
racketblock+eval (rename-out [racketblock+eval schemeblock+eval])
racketblock0+eval
racketmod+eval (rename-out [racketmod+eval schememod+eval])
def+int
defs+int
@ -68,14 +70,12 @@
(if (= 1 (length s))
(make-paragraph
(list
(hspace 2)
(literal-string style (car s))))
(make-table
#f
(map (lambda (s)
(list (make-flow (list (make-paragraph
(list
(hspace 2)
(literal-string style s)))))))
s))))))))))
@ -88,13 +88,11 @@
(define (add-line line-accum flow-accum)
(if line-accum
(cons (make-paragraph
(cons
(hspace 2)
(map (lambda (s)
(if (string? s)
(literal-string style s)
s))
(reverse line-accum))))
(map (lambda (s)
(if (string? s)
(literal-string style s)
s))
(reverse line-accum)))
flow-accum)
flow-accum))
(let loop ([string-accum #f] [line-accum #f] [flow-accum null])
@ -123,65 +121,76 @@
(loop #f (cons v (or (add-string string-accum line-accum) null))
flow-accum)]))))
(define (interleave title expr-paras val-list+outputs)
(make-table
#f
(append
(if title (list (list (make-flow (list title)))) null)
(let loop ([expr-paras expr-paras]
[val-list+outputs val-list+outputs]
[first? #t])
(if (null? expr-paras)
null
(append
(list (list (let ([p (car expr-paras)])
(if (flow? p)
p
(make-flow (list p))))))
(format-output (cadar val-list+outputs) output-color)
(format-output (caddar val-list+outputs) error-color)
(cond
[(string? (caar val-list+outputs))
;; Error result case:
(map
(lambda (s)
(car (format-output s error-color)))
(filter
(lambda (s) (not (equal? s "")))
(let sloop ([s (caar val-list+outputs)])
(apply
append
(map (lambda (s)
(if ((string-length s) . > . maxlen)
;; break the error message into multiple lines:
(let loop ([pos (sub1 maxlen)])
(cond
[(zero? pos) (cons (substring s 0 maxlen)
(sloop (substring s maxlen)))]
[(char-whitespace? (string-ref s pos))
(cons (substring s 0 pos)
(sloop (substring s (add1 pos))))]
[else (loop (sub1 pos))]))
(list s)))
(regexp-split #rx"\n" s))))))]
[(box? (caar val-list+outputs))
;; Output witten to a port
(format-output-stream (unbox (caar val-list+outputs)) result-color)]
[else
;; Normal result case:
(let ([val-list (caar val-list+outputs)])
(if (equal? val-list (list (void)))
null
(map (lambda (v)
(list (make-flow (list (make-paragraph
(list
(hspace 2)
(elem #:style result-color
(to-element/no-color v #:expr? (print-as-expression)))))))))
val-list)))])
(loop (cdr expr-paras)
(cdr val-list+outputs)
#f)))))))
(define (interleave inset? title expr-paras val-list+outputs)
(let ([lines
(let loop ([expr-paras expr-paras]
[val-list+outputs val-list+outputs]
[first? #t])
(if (null? expr-paras)
null
(append
(list (list (let ([p (car expr-paras)])
(if (flow? p)
p
(make-flow (list p))))))
(format-output (cadar val-list+outputs) output-color)
(format-output (caddar val-list+outputs) error-color)
(cond
[(string? (caar val-list+outputs))
;; Error result case:
(map
(lambda (s)
(car (format-output s error-color)))
(filter
(lambda (s) (not (equal? s "")))
(let sloop ([s (caar val-list+outputs)])
(apply
append
(map (lambda (s)
(if ((string-length s) . > . maxlen)
;; break the error message into multiple lines:
(let loop ([pos (sub1 maxlen)])
(cond
[(zero? pos) (cons (substring s 0 maxlen)
(sloop (substring s maxlen)))]
[(char-whitespace? (string-ref s pos))
(cons (substring s 0 pos)
(sloop (substring s (add1 pos))))]
[else (loop (sub1 pos))]))
(list s)))
(regexp-split #rx"\n" s))))))]
[(box? (caar val-list+outputs))
;; Output witten to a port
(format-output-stream (unbox (caar val-list+outputs)) result-color)]
[else
;; Normal result case:
(let ([val-list (caar val-list+outputs)])
(if (equal? val-list (list (void)))
null
(map (lambda (v)
(list (make-flow (list (make-paragraph
(list
(elem #:style result-color
(to-element/no-color v #:expr? (print-as-expression)))))))))
val-list)))])
(loop (cdr expr-paras)
(cdr val-list+outputs)
#f))))])
(if inset?
(let ([p (code-inset (make-table #f lines))])
(if title
(make-table
#f
(list
(list (make-flow (list title)))
(list (make-flow (list p)))))
p))
(make-table #f
(append
(if title
(list (list (make-flow (list title))))
null)
lines)))))
;; extracts from a datum or syntax object --- while keeping the
;; syntax-objectness of the original intact, instead of always
@ -428,46 +437,52 @@
(define-syntax racketinput*
(syntax-rules (eval:alts code:comment)
[(_ (code:comment . rest)) (racketblock (code:comment . rest))]
[(_ (code:comment . rest)) (racketblock0 (code:comment . rest))]
[(_ (eval:alts a b)) (racketinput* a)]
[(_ e) (racketinput e)]))
[(_ e) (racketinput0 e)]))
(define-code racketblock+line (to-paragraph/prefix (hspace 2)
(hspace 2)
(list " ")))
(define-code racketblock0+line (to-paragraph/prefix "" "" (list " ")))
(define-syntax (racketdefinput* stx)
(syntax-case stx (define define-values define-struct)
[(_ (define . rest))
(syntax-case stx ()
[(_ e) #'(racketblock+line e)])]
[(_ e) #'(racketblock0+line e)])]
[(_ (define-values . rest))
(syntax-case stx ()
[(_ e) #'(racketblock+line e)])]
[(_ e) #'(racketblock0+line e)])]
[(_ (define-struct . rest))
(syntax-case stx ()
[(_ e) #'(racketblock+line e)])]
[(_ e) #'(racketblock0+line e)])]
[(_ (code:line (define . rest) . rest2))
(syntax-case stx ()
[(_ e) #'(racketblock+line e)])]
[(_ e) #'(racketblock0+line e)])]
[(_ e) #'(racketinput* e)]))
(define (do-titled-interaction ev t shows evals)
(interleave t
(define (do-titled-interaction inset? ev t shows evals)
(interleave inset?
t
shows
(map (do-eval ev) evals)))
(define-syntax titled-interaction
(syntax-rules ()
[(_ #:eval ev t racketinput* e ...)
(do-titled-interaction ev t (list (racketinput* e) ...) (list (quote-expr e) ...))]
[(_ t racketinput* e ...)
(titled-interaction #:eval (make-base-eval) t racketinput* e ...)]))
[(_ inset? #:eval ev t racketinput* e ...)
(do-titled-interaction inset? ev t (list (racketinput* e) ...) (list (quote-expr e) ...))]
[(_ inset? t racketinput* e ...)
(titled-interaction inset? #:eval (make-base-eval) t racketinput* e ...)]))
(define (code-inset p)
(make-blockquote 'code-inset (list p)))
(define-syntax interaction
(syntax-rules ()
[(_ #:eval ev e ...) (titled-interaction #:eval ev #f racketinput* e ...)]
[(_ e ...) (titled-interaction #f racketinput* e ...)]))
[(_ e ...) (code-inset (interaction0 e ...))]))
(define-syntax interaction0
(syntax-rules ()
[(_ #:eval ev e ...) (titled-interaction #f #:eval ev #f racketinput* e ...)]
[(_ e ...) (titled-interaction #f #f racketinput* e ...)]))
(define-syntax racketblock+eval
(syntax-rules ()
@ -479,6 +494,16 @@
[(_ e ...)
(racketblock+eval #:eval (make-base-eval) e ...)]))
(define-syntax racketblock0+eval
(syntax-rules ()
[(_ #:eval ev e ...)
(let ([eva ev])
(#%expression
(begin (interaction-eval #:eval eva e) ...
(racketblock0 e ...))))]
[(_ e ...)
(racketblock0+eval #:eval (make-base-eval) e ...)]))
(define-syntax racketmod+eval
(syntax-rules ()
[(_ #:eval ev name e ...)
@ -493,9 +518,9 @@
(syntax-rules ()
[(_ #:eval ev def e ...)
(let ([eva ev])
(column (list (racketblock+eval #:eval eva def)
(column (list (racketblock0+eval #:eval eva def)
blank-line
(interaction #:eval eva e ...))))]
(interaction0 #:eval eva e ...))))]
[(_ def e ...)
(def+int #:eval (make-base-eval) def e ...)]))
@ -503,9 +528,9 @@
(syntax-rules ()
[(_ #:eval ev [def ...] e ...)
(let ([eva ev])
(column (list (racketblock+eval #:eval eva def ...)
(column (list (racketblock0+eval #:eval eva def ...)
blank-line
(interaction #:eval eva e ...))))]
(interaction0 #:eval eva e ...))))]
[(_ [def ...] e ...)
(defs+int #:eval (make-base-eval) [def ...] e ...)]))
@ -522,35 +547,36 @@
(define-syntax examples
(syntax-rules ()
[(_ #:eval ev e ...)
(titled-interaction #:eval ev (pick-example-title e ...) racketinput* e ...)]
(titled-interaction #t #:eval ev (pick-example-title e ...) racketinput* e ...)]
[(_ e ...)
(titled-interaction (pick-example-title e ...) racketinput* e ...)]))
(titled-interaction #t (pick-example-title e ...) racketinput* e ...)]))
(define-syntax examples*
(syntax-rules ()
[(_ #:eval ev example-title e ...)
(titled-interaction #:eval ev example-title racketinput* e ...)]
(titled-interaction #t #:eval ev example-title racketinput* e ...)]
[(_ example-title e ...)
(titled-interaction example-title racketinput* e ...)]))
(titled-interaction #t example-title racketinput* e ...)]))
(define-syntax defexamples
(syntax-rules ()
[(_ #:eval ev e ...)
(titled-interaction #:eval ev (pick-example-title e ...) racketdefinput* e ...)]
(titled-interaction #t #:eval ev (pick-example-title e ...) racketdefinput* e ...)]
[(_ e ...)
(titled-interaction (pick-example-title e ...) racketdefinput* e ...)]))
(titled-interaction #t (pick-example-title e ...) racketdefinput* e ...)]))
(define-syntax defexamples*
(syntax-rules ()
[(_ #:eval ev example-title e ...)
(titled-interaction #:eval ev example-title racketdefinput* e ...)]
(titled-interaction #t #:eval ev example-title racketdefinput* e ...)]
[(_ example-title e ...)
(titled-interaction example-title racketdefinput* e ...)]))
(titled-interaction #t example-title racketdefinput* e ...)]))
(define blank-line (make-paragraph (list 'nbsp)))
(define (column l)
(make-table #f (map
(lambda (t)
(list (make-flow (list t))))
l)))
(code-inset
(make-table #f (map
(lambda (t)
(list (make-flow (list t))))
l))))
(define (do-splice l)
(cond

10
collects/scribble/html-render.rkt
View File

@ -1254,10 +1254,12 @@
(define/override (render-nested-flow t part ri)
`((blockquote [,@(style->attribs (nested-flow-style t))
,@(if (and (not (string? (style-name (nested-flow-style t))))
(not (eq? 'inset (style-name (nested-flow-style t)))))
`([class "SubFlow"])
null)]
,@(if (eq? 'code-inset (style-name (nested-flow-style t)))
`([class "SCodeFlow"])
(if (and (not (string? (style-name (nested-flow-style t))))
(not (eq? 'inset (style-name (nested-flow-style t)))))
`([class "SubFlow"])
null))]
,@(append-map (lambda (i) (render-block i part ri #f))
(nested-flow-blocks t)))))

3
collects/scribble/latex-render.rkt
View File

@ -550,7 +550,8 @@
(define/private (do-render-nested-flow t part ri single-column?)
(let* ([kind (or (let ([s (style-name (nested-flow-style t))])
(or (and (string? s) s)
(and (eq? s 'inset) "quote")))
(and (eq? s 'inset) "quote")
(and (eq? s 'code-inset) "SCodeFlow")))
"Subflow")]
[props (style-properties (nested-flow-style t))]
[command? (memq 'command props)]

16
collects/scribble/private/manual-code.rkt
View File

@ -5,19 +5,21 @@
"../core.rkt"
"../base.rkt"
"manual-scheme.rkt"
scribble/core
(for-syntax racket/base
syntax/parse))
(provide codeblock
codeblock0
typeset-code)
(define-syntax (codeblock stx)
(define-for-syntax (do-codeblock stx)
(syntax-parse stx
[(_ (~seq (~or (~optional (~seq #:expand expand-expr:expr)
#:defaults ([expand-expr #'#f])
#:name "#:expand keyword")
(~optional (~seq #:indent indent-expr:expr)
#:defaults ([indent-expr #'2])
#:defaults ([indent-expr #'0])
#:name "#:expand keyword")
(~optional (~seq #:keep-lang-line? keep-lang-line?-expr:expr)
#:defaults ([keep-lang-line?-expr #'#t])
@ -38,6 +40,12 @@
#`#'#,(car (syntax-e v))))
#'#f)))]))
(define (code-inset p)
(make-nested-flow (make-style 'code-inset '()) (list p)))
(define-syntax (codeblock stx) #`(code-inset #,(do-codeblock stx)))
(define-syntax (codeblock0 stx) (do-codeblock stx))
(define (typeset-code #:context [context #f]
#:expand [expand #f]
#:indent [indent 2]
@ -199,7 +207,9 @@
(define (make-line accum-line) (list (paragraph omitable
(cons indent-elem
(reverse accum-line)))))
(define indent-elem (hspace indent-amt))
(define indent-elem (if (zero? indent-amt)
""
(hspace indent-amt)))
(let loop ([l l] [accum-line null])
(cond
[(null? l) (if (null? accum-line)

51
collects/scribble/private/manual-scheme.rkt
View File

@ -15,8 +15,10 @@
racketresultblock racketresultblock0
RACKETRESULTBLOCK RACKETRESULTBLOCK0
racketblockelem
racketinput RACKETINPUT
racketmod
racketinput RACKETINPUT
racketinput0 RACKETINPUT0
racketmod
racketmod0
racket RACKET racket/form racketresult racketid
racketmodname
racketmodlink indexed-racket
@ -42,11 +44,16 @@
[racketlink schemelink]))
(define-code racketblock0 to-paragraph)
(define-code racketblock (to-paragraph/prefix (hspace 2) (hspace 2) ""))
(define-code RACKETBLOCK (to-paragraph/prefix (hspace 2) (hspace 2) "")
UNSYNTAX)
(define-code racketblock to-block-paragraph)
(define-code RACKETBLOCK to-block-paragraph UNSYNTAX)
(define-code RACKETBLOCK0 to-paragraph UNSYNTAX)
(define (code-inset b)
(make-blockquote 'code-inset (list b)))
(define (to-block-paragraph v)
(code-inset (to-paragraph v)))
(define (to-result-paragraph v)
(to-paragraph v
#:color? #f
@ -67,19 +74,22 @@
(define-code RACKETRESULTBLOCK0 to-result-paragraph UNSYNTAX)
(define interaction-prompt (make-element 'tt (list "> " )))
(define-code racketinput
(to-paragraph/prefix
(make-element #f (list (hspace 2) interaction-prompt))
(hspace 4)
""))
(define-code RACKETINPUT
(to-paragraph/prefix
(make-element #f (list (hspace 2) interaction-prompt))
(hspace 4)
"")
UNSYNTAX)
(define-code racketinput to-input-paragraph/inset)
(define-code RACKETINPUT to-input-paragraph/inset)
(define-code racketinput0 to-input-paragraph)
(define-code RACKETINPUT0 to-input-paragraph)
(define-syntax (racketmod stx)
(define to-input-paragraph
(to-paragraph/prefix
(make-element #f interaction-prompt)
(hspace 2)
""))
(define to-input-paragraph/inset
(lambda (v)
(code-inset (to-input-paragraph v))))
(define-syntax (racketmod0 stx)
(syntax-case stx ()
[(_ #:file filename lang rest ...)
(with-syntax ([modtag (datum->syntax
@ -99,9 +109,12 @@
(filebox
filename
#,(syntax/loc stx (racketblock0 modtag rest ...))))
(syntax/loc stx (racketblock modtag rest ...))))]
(syntax/loc stx (racketblock0 modtag rest ...))))]
[(_ lang rest ...)
(syntax/loc stx (racketmod #:file #f lang rest ...))]))
(syntax/loc stx (racketmod0 #:file #f lang rest ...))]))
(define-syntax-rule (racketmod rest ...)
(code-inset (racketmod0 rest ...)))
(define (to-element/result s)
(make-element result-color (list (to-element/no-color s))))

8
collects/scribble/scribble.css
View File

@ -359,6 +359,14 @@ ol ol ol ol { list-style-type: upper-alpha; }
i {
}
.SCodeFlow {
display: block;
margin-left: 1em;
margin-bottom: 0em;
margin-right: 0em;
margin-top: 0em;
}
.SubFlow {
display: block;
margin: 0em;

8
collects/scribble/scribble.tex
View File

@ -74,6 +74,7 @@
\newcommand{\atItemizeStart}[0]{\addtolength{\stabLeft}{\labelsep}
\addtolength{\stabLeft}{\labelwidth}}
% For a single-column table in simple environments, it's better to
% use the `list' environment instead of `stabular'.
\newenvironment{SingleColumn}{\begin{list}{}{\topsep=0pt\partopsep=0pt%
@ -92,7 +93,12 @@
\listparindent=0pt\itemindent=0pt\labelwidth=0pt\leftmargin=0pt\rightmargin=0pt%
\itemsep=0pt}\item}{\end{list}}
% The 'inset neested-flow style uses the `quote' environment
% The 'inset nested-flow style uses the `quote' environment
% Indent a 'code-inset nested flow:
\newenvironment{SCodeFlow}{\begin{list}{}{\topsep=0pt\partopsep=0pt%
\listparindent=0pt\itemindent=0pt\labelwidth=0pt\leftmargin=2ex\rightmargin=0pt%
\itemsep=0pt\parsep=0pt}\item}{\end{list}}
% The 'compact itemization style:
\newenvironment{compact}{\begin{itemize}}{\end{itemize}}

8
collects/scribble/sigplan/style.tex
View File

@ -18,3 +18,11 @@
\renewcommand{\SCategoryPlus}[4]{\category{#1}{#2}{#3}[#4]}
\renewcommand{\STerms}[1]{\terms{#1}}
\renewcommand{\SKeywords}[1]{\keywords{#1}}
% Add space around code insets:
% Indent a 'code-inset nested flow:
\newcommand{\SCodePreSkip}{\vskip\medskipamount}
\newcommand{\SCodePostSkip}{\vskip\medskipamount}
\renewenvironment{SCodeFlow}{\SCodePreSkip\begin{list}{}{\topsep=0pt\partopsep=0pt%
\listparindent=0pt\itemindent=0pt\labelwidth=0pt\leftmargin=2ex\rightmargin=0pt%
\itemsep=0pt\parsep=0pt}\item}{\end{list}\SCodePostSkip}

5
collects/scribblings/scribble/base.scrbl
View File

@ -159,8 +159,9 @@ address-harvesting robots.}
@racket[pre-flow] (i.e., parsed with @racket[decode-flow]).
The @racket[style] argument is handled the same as @racket[para].
The @racket['inset] style causes the nested flow to be inset compared
to surrounding text.}
The @racket['inset] and @racket['code-inset] styles cause the nested
flow to be inset compared to surrounding text, with the latter
particularly intended for insetting code.}
@defproc[(centered [pre-flow pre-flow?] ...) nested-flow?]{

3
collects/scribblings/scribble/core.scrbl
View File

@ -540,6 +540,9 @@ names are recognized:
@item{@racket['inset] --- Insets the nested flow relative to
surrounding text.}
@item{@racket['code-inset] --- Insets the nested flow relative to
surrounding text in a way suitable for code.}
]
The following @tech{style properties} are currently recognized:

10
collects/scribblings/scribble/eval.scrbl
View File

@ -47,6 +47,10 @@ If a @racket[datum] has the form
expect-datum))], then both @svar[eval-datum] and @svar[check-datum]
are evaluated, and an error is raised if they are not @racket[equal?].}
@defform*[[(interaction0 datum ...)
(interaction0 #:eval eval-expr datum ...)]]{
Like @racket[interaction], but without insetting the code via
@racket[nested].}
@defform*[[(interaction-eval datum)
(interaction-eval #:eval eval-expr datum)]]{
@ -68,6 +72,12 @@ the printed form of the evaluation result.}
Combines @racket[racketblock] and @racket[interaction-eval].}
@defform*[[(racketblock0+eval datum ...)
(racketblock0+eval #:eval eval-expr datum ...)]]{
Combines @racket[racketblock0] and @racket[interaction-eval].}
@defform*[[(racketmod+eval name datum ...)
(racketmod+eval #:eval eval-expr name datum ...)]]{

37
collects/scribblings/scribble/manual.scrbl
View File

@ -42,13 +42,16 @@ includes a @racket[latex-defaults] @tech{style property}.
Parses the code formed by the strings produced by the
@racket[str-expr]s as a Racket module (roughly) and produces a
@tech{block} that typesets the code. The @racket[str-expr]s should
normally start with @hash-lang[] to determine the reader syntax for
the module, but the resulting ``module'' need not expand or
compile---except as needed by @racket[expand-expr]. If
@racket[expand-expr] is omitted or produces false, then the input
formed by @racket[str-expr] is read until an end-of-file is
encountered, otherwise a single form is read from the input.
@tech{block} that typesets the code inset via @racket[nested] with the
style @racket['code-inset].
The @racket[str-expr]s should normally start with @hash-lang[] to
determine the reader syntax for the module, but the resulting
``module'' need not expand or compile---except as needed by
@racket[expand-expr]. If @racket[expand-expr] is omitted or produces
false, then the input formed by @racket[str-expr] is read until an
end-of-file is encountered, otherwise a single form is read from the
input.
When @racket[keep-expr] produces a true value (the default), the first
line in the input (which is typically @hash-lang[]) is preserved in
@ -94,8 +97,9 @@ produces the typeset result
@defform[(racketblock datum ...)]{
Typesets the @racket[datum] sequence as a table of Racket code inset
by two spaces. The source locations of the @racket[datum]s determine
the generated layout. For example,
inset via @racket[nested] with the style @racket['code-inset]. The
source locations of the @racket[datum]s determine the generated
layout. For example,
@racketblock[
(racketblock
@ -196,10 +200,10 @@ See also @racketmodname[scribble/comment-reader].
the expression escape @racket[UNSYNTAX] instead of @racket[unsyntax].}
@defform[(racketblock0 datum ...)]{Like @racket[racketblock], but
without insetting the code.}
without insetting the code via @racket[nested].}
@defform[(RACKETBLOCK0 datum ...)]{Like @racket[RACKETBLOCK], but
without insetting the code.}
without insetting the code via @racket[nested].}
@deftogether[(
@defform[(racketresultblock datum ...)]
@ -217,6 +221,13 @@ result (i.e., a single color with no hyperlinks) instead of code.}
)]{Like @racket[racketblock] and @racket[RACKETBLOCK], but the
@racket[datum]s are typeset after a prompt representing a REPL.}
@deftogether[(
@defform[(racketinput0 datum ...)]
@defform[(RACKETINPUT0 datum ...)]
)]{
Like @racket[racketinput] and @racket[RACKETINPUT], but
without insetting the code via @racket[nested].}
@defform/subs[(racketmod maybe-file lang datum ...)
([maybe-file code:blank
(code:line #:file filename-expr)])]{
@ -233,6 +244,10 @@ If @racket[#:file] is provided, then the code block is typeset using
@racket[filebox] with @racket[filename-expr] as the filename
argument.}
@defform[(racketmod0 maybe-file lang datum ...)]{
Like @racket[racketmod], but
without insetting the code via @racket[nested].}
@defform[(racket datum ...)]{Like @racket[racketblock], but typeset on
a single line and wrapped with its enclosing paragraph, independent of
the formatting of @racket[datum].}

16
collects/scribblings/scribble/srcdoc.scrbl
View File

@ -71,18 +71,18 @@ to get core Racket forms and basic Scribble functions to use in
documentation expressions.}
@defform*/subs[#:literals (-> ->* case->)
[(proc-doc/names id contract ((arg-id ...) ((arg-id default-expr) ...)) desc-expr)
(proc-doc/names id case-contract ((arg-id ...) ((arg-id default-expr) ...)) desc-expr)]
[(proc-doc/names id contract ((arg-id ...) ((arg-id default-expr) ...))
desc-expr)]
([contract (-> arg ... result)
(->* (mandatory ...) (optional ...) result)]
(->* (mandatory ...) (optional ...) result)
(case-> (-> arg ... result) ...)]
[mandatory contract-expr
(code:line keyword contract-expr)]
[optional contract-expr
(code:line keyword contract-expr)]
[case-contract (case-> (-> arg ... result) ...)])]{
(code:line keyword contract-expr)])]{
When used in @racket[provide/doc], exports @racket[id] with the
contract described by @racket[contract] or @racket[case-contract],
contract described by @racket[contract]
just like using @racket[provide/contract].
The @racket[arg-id]s specify the names of arguments, which are not
@ -108,9 +108,9 @@ form.}
(proc-doc id contract desc-expr)
([contract (-> result)
(->d (arg ...) () (values [id result] ...))
(->d (arg ...) () #:pre-cond expression (values [id result] ...))
(->d (arg ...) () #:pre-cond expr (values [id result] ...))
(->d (arg ...) () [id result])
(->d (arg ...) () #:pre-cond expression [id result])
(->d (arg ...) () #:pre-cond expr [id result])
(->d (arg ...) () #:rest id rest [id result])])]{
Like @racket[proc-doc], but supporting contract forms that embed

4
src/racket/src/schvers.h
View File

@ -13,12 +13,12 @@
consistently.)
*/
#define MZSCHEME_VERSION "5.1.0.4"
#define MZSCHEME_VERSION "5.1.0.5"
#define MZSCHEME_VERSION_X 5
#define MZSCHEME_VERSION_Y 1
#define MZSCHEME_VERSION_Z 0
#define MZSCHEME_VERSION_W 4
#define MZSCHEME_VERSION_W 5
#define MZSCHEME_VERSION_MAJOR ((MZSCHEME_VERSION_X * 100) + MZSCHEME_VERSION_Y)
#define MZSCHEME_VERSION_MINOR ((MZSCHEME_VERSION_Z * 1000) + MZSCHEME_VERSION_W)