commit 742843af7b3ac29dd1a32bb9213d859ab69a5074
parent 1f7cb9b151fa9f5c12750276e9e2faaf0ec2cda4
Author: Matthew Flatt <mflatt@racket-lang.org>
Date: Wed, 30 Mar 2011 12:57:10 -0600
Scribble: change the way `racketblock' etc. indent/inset works
- 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
original commit: bbc5533938b1dac8f14005210fa9fe552dfa7e8c
Diffstat:
13 files changed, 251 insertions(+), 148 deletions(-)
diff --git a/collects/scribble/eval.rkt b/collects/scribble/eval.rkt
@@ -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
diff --git a/collects/scribble/html-render.rkt b/collects/scribble/html-render.rkt
@@ -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)))))
diff --git a/collects/scribble/latex-render.rkt b/collects/scribble/latex-render.rkt
@@ -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)]
diff --git a/collects/scribble/private/manual-code.rkt b/collects/scribble/private/manual-code.rkt
@@ -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)
diff --git a/collects/scribble/private/manual-scheme.rkt b/collects/scribble/private/manual-scheme.rkt
@@ -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
+(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 to-input-paragraph
(to-paragraph/prefix
- (make-element #f (list (hspace 2) interaction-prompt))
- (hspace 4)
+ (make-element #f interaction-prompt)
+ (hspace 2)
""))
-(define-code RACKETINPUT
- (to-paragraph/prefix
- (make-element #f (list (hspace 2) interaction-prompt))
- (hspace 4)
- "")
- UNSYNTAX)
+
+(define to-input-paragraph/inset
+ (lambda (v)
+ (code-inset (to-input-paragraph v))))
-(define-syntax (racketmod stx)
+(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))))
diff --git a/collects/scribble/scribble.css b/collects/scribble/scribble.css
@@ -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;
diff --git a/collects/scribble/scribble.tex b/collects/scribble/scribble.tex
@@ -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}}
diff --git a/collects/scribble/sigplan/style.tex b/collects/scribble/sigplan/style.tex
@@ -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}
diff --git a/collects/scribblings/scribble/base.scrbl b/collects/scribblings/scribble/base.scrbl
@@ -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?]{
diff --git a/collects/scribblings/scribble/core.scrbl b/collects/scribblings/scribble/core.scrbl
@@ -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:
diff --git a/collects/scribblings/scribble/eval.scrbl b/collects/scribblings/scribble/eval.scrbl
@@ -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 ...)]]{
diff --git a/collects/scribblings/scribble/manual.scrbl b/collects/scribblings/scribble/manual.scrbl
@@ -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].}
diff --git a/collects/scribblings/scribble/srcdoc.scrbl b/collects/scribblings/scribble/srcdoc.scrbl
@@ -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
