home: hub: zuo

Info  •  Files  •  Log

Zuo: fix contract, link, and text issues

--- a/zuo-doc/lang-zuo-hygienic.scrbl

+++ b/zuo-doc/lang-zuo-hygienic.scrbl

@@ -57,10 +57,10 @@

 @tech{syntax objects}:

 @deftogether[(

-@defproc[(identifier? [v any?]) boolean?]

+@defproc[(identifier? [v any/c]) boolean?]

 @defproc[(syntax-e [v identifier?]) symbol?]

-@defproc[(syntax->datum [v any?]) any?]

-@defproc[(datum->syntax [ctx identifier?] [v any?]) any?]

+@defproc[(syntax->datum [v any/c]) any/c]

+@defproc[(datum->syntax [ctx identifier?] [v any/c]) any/c]

 @defproc[(bound-identifier=? [id1 identifier?]

                              [id2 identifier?]) boolean?]

 )]{

--- a/zuo-doc/lang-zuo.scrbl

+++ b/zuo-doc/lang-zuo.scrbl

@@ -37,7 +37,7 @@

 A @racketmodname[zuo] module consists of a sequence of definitions

 (e.g., @racket[define]), macro definitions (e.g.,

 @racket[define-syntax]), imports (e.g., @racket[require]), exports

-(e.g., @racket[provides]), and expressions (e.g., @racket[5]). Loading

+(e.g., @racket[provide]), and expressions (e.g., @racket[5]). Loading

 the module first @deftech{expands} it, and then @deftech{evaluates}

 it. A module is loaded only once, so if a module is demanded more than

 once, the result of the first load is used.

@@ -59,7 +59,7 @@

 evaluation is an error. The value of each expression in a module body

 is printed using @racket[alert] compiled with @racket[~v].

-A module's provided variables and syntax are made available to other

+A module's provided variables and macros are made available to other

 modules that import it. Variables and macros that are not provided are

 completely inaccessible outside of the module.

@@ -90,7 +90,7 @@

 @section{Binding and Control Forms}

 A @racketmodname[zuo] syntactic form is either a @deftech{definition}

-form or an @deftech{expression forms}. Expressions can appear in

+form or an @deftech{expression} form. Expressions can appear in

 definition contexts, but not vice versa. In descriptions of syntactic

 forms @racket[_body ...+] refers to a context that allows definition

 forms, but the last form in the expansion of the definition context

@@ -156,8 +156,8 @@

 Analogous to @realracket[quote-syntax] from @racketmodname[racket],

 but only identifiers have a specialized syntax-object representation

-in place of symbols. Tree structure in @racket[datum] represented

-using plain pairs, and non-identifier elements of @racket[datums] are

+in place of symbols. Tree structure in @racket[datum] is represented

+using plain pairs, and non-identifier elements are

 represented with plain numbers, strings, etc.

 A Zuo module's representation starts with plain pairs and symbols, a

@@ -189,7 +189,7 @@

 @defform[(quote-module-path)]{

-Returns the module path of the enclosing module.}

+Produces the module path of the enclosing module.}

 @subsection{Definition Forms}

@@ -250,7 +250,7 @@

                     [maybe-renamed-id id

                                       renamed-id]

                     [renamed-id [provided-id id]])]

-@defform[#:literals (all-from-out)

+@defform[#:literals (rename-out all-from-out)

          (provide spec ...)

          #:grammar ([spec id

                           (rename-out renamed-id ...)

@@ -274,7 +274,7 @@

 from the symbol form of @racket[id] in the encloding module's

 representation as a hash table (see @secref["module-protocol"]).

 Calling the procedure evaluates the @racket[defn-or-expr] content of

-the submodule, where expression results are printed and the procedure

+the submodule, where expression results are printed and the procedure's

 result is @racket[(void)].

 When Zuo loads a starting module (see @secref["running"]), it checks

@@ -293,16 +293,16 @@

 @defproc[(not [v any/c]) boolean?]

 )]{

-Just like @realracket*[boolean? not] from @racket[racket].}

+Just like @realracket*[boolean? not] from @racketmodname[racket].}

 @defproc[(eq? [v1 any/c] [v2 any/c]) boolean?]{

-Analogous to @realracket[eq?] from @racket[racket], but even small Zuo

+Analogous to @realracket[eq?] from @racketmodname[racket], but even small Zuo

 numbers are not necessarily @racket[eq?] when they are @racket[=].}

 @defproc[(equal? [v1 any/c] [v2 any/c]) boolean?]{

-Analogous to @realracket[equal?] from @racket[racket].}

+Analogous to @realracket[equal?] from @racketmodname[racket].}

 @section{Numbers}

@@ -388,17 +388,17 @@

 @deftogether[(

 @defproc[(map [proc procedure?] [lst list?] ...+)

          list?]

-@defproc[(for-each [proc procedure?] [lst list?])

+@defproc[(for-each [proc (any/c . -> . any/c)] [lst list?])

          void?]

-@defproc[(foldl [proc procedure?] [init any/c] [lst list?])

+@defproc[(foldl [proc (any/c any/c . -> . any/c)] [init any/c] [lst list?])

          any/c]

-@defproc[(andmap [proc procedure?] [lst list?])

+@defproc[(andmap [proc (any/c . -> . any/c)] [lst list?])

           any/c]

-@defproc[(ormap [proc procedure?] [lst list?])

+@defproc[(ormap [proc (any/c . -> . any/c)] [lst list?])

          any/c]

-@defproc[(filter [proc procedure?] [lst list?])

+@defproc[(filter [proc (any/c . -> . any/c)] [lst list?])

          list?]

-@defproc[(sort [lst list?] [less-than? procedure?])

+@defproc[(sort [lst list?] [less-than? (any/c any/c . -> . any/c)])

          list?]

 )]{

@@ -435,9 +435,9 @@

 )]{

 Analogous to @realracket*[string? string string-length string-ref substring

-string=? string<?] from @racketmodname[racket], or more precisely analogous to

-@realracket*[bytes? bytes-length bytes-ref subbytes bytes=? bytes-ci=?] from

-@racketmodname[racket].}

+string=? string-ci=? string<?] from @racketmodname[racket], or more precisely analogous to

+@realracket*[bytes? bytes bytes-length bytes-ref subbytes bytes=? bytes<?]

+(and, in principle, @racket[bytes-ci=?]) from @racketmodname[racket].}

 @defproc[(string-u32-ref [str string?] [k integer?]) integer?]{

@@ -459,10 +459,10 @@

 @defform[(char str)]{

 Expands to @racket[(string-ref str 0)], where @racket[str] must be a

-string of length 1.}

+literal string of length 1.}

-@defproc*[([(string-split [str string?]) list?]

-           [(string-split [str string?] [sep string?]) list?])]{

+@defproc*[([(string-split [str string?]) (listof string?)]

+           [(string-split [str string?] [sep string?]) (listof string?)])]{

 Breaks @racket[str] into a sequence of substrings that have a

 non-empty separator string in between. When @racket[sep] is not

@@ -499,7 +499,7 @@

 @tech{hash table}.

 The textual representation of symbols does not include escapes for

-special character, analogous to the way @litchar{|} works in Racket.

+special character, unlike the way @litchar{|} works in Racket.

 Symbols with those characters will print in a way that cannot be read

 back into Zuo.

@@ -536,11 +536,11 @@

                       [key symbol?]

                       [failure-value any/c])

             any/c])]

-@defproc[(hash-set [hash (and/c hash? immutable?)]

+@defproc[(hash-set [hash hash?]

                    [key symbol?]

                    [v any/c])

          hash?]

-@defproc[(hash-remove [hash (and/c hash? immutable?)]

+@defproc[(hash-remove [hash hash?]

                       [key symbol?])

          hash?]

 @defproc[(hash-keys [hash hash?]) (listof symbol?)]

@@ -572,8 +572,8 @@

 @deftogether[(

 @defproc[(procedure? [v any/c]) any/c]

 @defproc[(apply [proc procedure?] [lst list?]) any/c]

-@defproc[(call/cc [proc procedure?]) any/c]

-@defproc[(call/prompt [proc procedure?] [tag symbol?]) any/c]

+@defproc[(call/cc [proc (any/c . -> . any/c)]) any/c]

+@defproc[(call/prompt [proc (-> any/c)] [tag symbol?]) any/c]

 @defproc[(continuation-prompt-available? [tag symbol?]) boolean?]

 )]{

@@ -597,12 +597,12 @@

 @defproc[(relative-path? [path path-string?]) boolean?]{

-Returns @racket[#t] if @racket[v] is a relative path, @racket[#f] otherwise.}

+Returns @racket[#t] if @racket[path] is a relative path, @racket[#f] otherwise.}

 @defproc[(build-raw-path [base path-string?] [rel path-string?] ...) path-string?]{

-Combines @racket[base] path (absolute or relative) with the relative

-paths @racket[rel], adding path separators as needed.}

+Combines @racket[base] path (absolute or relative) with relative

+@racket[rel] paths, adding path separators as needed.}

 @defproc[(build-path [base path-string?] [rel path-string?] ...) path-string?]{

@@ -717,7 +717,7 @@

 @defproc[(opaque-ref [key any/c] [v any/c] [failure-val any/c]) any/c]{

-Returns the value encapsulated in @racket[v] if its is an opaque

+Returns the value encapsulated in @racket[v] if it is an opaque

 object with access allowed via @racket[key], @racket[failure-val] otherwise.}

@@ -767,7 +767,7 @@

 @defproc[(build-module-path [base module-path?] [rel-path path-string?]) module-path?]{

 Analogous to @racket[build-path], but for @tech{module paths}. The

-@racket[rel-path] string must end with @litchar{.zou}, and the

+@racket[rel-path] string must end with @litchar{.zuo}, and the

 characters of @racket[rel-path] must be allowable in a symbol module

 paths, except for a @litchar{.} in @filepath{.} and @filepath{..}

 elements or a @litchar{.zuo} suffix.}

@@ -776,7 +776,7 @@

 Loads @racket[mod-path] if it has not been loaded already, and returns

 the @tech{hash table} representation of the loaded module. See also

-@secref["module-protocol"]}

+@secref["module-protocol"].}

 @defproc[(dynamic-require [mod-path module-path?] [export symbol?]) any/c]{

@@ -853,11 +853,11 @@

 Errors (and exits) after printing the @racket[v]s to standard error,

 using an error color if standard error is a terminal.

-If the first @racket[v] is a string, its character are printed output

-@realracket[display]-style, and then @litchar{: } is printed. All

+If the first @racket[v] is a string, its characters are printed

+followed by @litchar{: }. All

 other @racket[v]s (including the first one if it's not a string) are

-combined using @racket[~v], and that resulting string is written

-@realracket[display]-style.}

+combined using @racket[~v], and that resulting string's characters are

+printed.}

 @defproc[(alert [v any/c] ...) void?]{

@@ -928,7 +928,7 @@

 @section{Files, Streams, and Processes}

-Files, input and out streams more generally, and processes are all

+Files, input and output streams, and processes are all

 represented as @tech{handles}.

 @defproc[(handle? [v any/c]) boolean?]{

@@ -1005,7 +1005,7 @@

 The number of bytes in the returned string can be less than

 @racket[amount] if the number of currently available bytes is less

 than @racket[amount] but at least one byte. The result can be an empty

-string only if @racket[amount] is @racket[0] or @racket['avail].

+string only if @racket[amount] is @racket[0] or @racket[eof].

 On Windows, @racket['avail] mode is not supported for console input.

@@ -1049,8 +1049,8 @@

 @racket[fd-open-input] or @racket[fd-open-output] }

 @deftogether[(

-@defproc[(file->string [name path-string]) string?]

-@defproc[(display-to-file [str string?] [name path-string] [options hash? (hash)]) void?]

+@defproc[(file->string [name path-string?]) string?]

+@defproc[(display-to-file [str string?] [name path-string?] [options hash? (hash)]) void?]

 )]{

 Convenience function to open @racket[name] and read its content into a

@@ -1061,12 +1061,12 @@

 A constant representing an end-of-file.}

 @deftogether[(

-@defproc[(cleanable-file [name path?]) handle?]

+@defproc[(cleanable-file [name path-string?]) handle?]

 @defproc[(cleanable-cancel [cleanable handle?]) void?]

 )]{

-The @racket[cleanable-file] function register @racket[name] as a file

-name to delete on any exit, including errors or termination signals,

+The @racket[cleanable-file] function registers @racket[name] as a file

+to delete on any exit, including errors or termination signals,

 unless @racket[cleanable-cancel] is called on the handle to cancel the

 clean-up action.}

@@ -1128,7 +1128,7 @@

       closed before waiting for processes to exit.}

 @item{@racket['exact?] mapped to boolean (or any value): if not

-      @racket[#f], a single @racket[arg] must be provided, and it is

+      @racket[#f], a single @racket[args] must be provided, and it is

       provided as-is for the created process's command line on

       Windows. A non-@racket[#f] value for @racket['exact?] is not

       allowed on Unix.}

@@ -1136,9 +1136,9 @@

 @item{@racket['exec?] mapped to boolean (or any value): if not

       @racket[#f], the target executable is run in the current

       process, after waiting for any other subprocesses and deleting

-      cleanables. A non-@racket[#f] value for @racket['exact?] is not

+      cleanables. A non-@racket[#f] value for @racket['exec?] is not

       allowed on Windows or, more generally, when @racket[(hash-ref

-      (runtime-env) 'can-exec?)] produced @racket[#f].}

+      (runtime-env) 'can-exec?)] is @racket[#f].}

 ]

@@ -1162,7 +1162,7 @@

 Returns @racket['running] if the process represented by

 @racket[process] is still running, the exit value if the process has

-exited (@racket[0] normally means succes), erroring for any other kind

+exited (@racket[0] normally means success), erroring for any other kind

 of handle.}

@@ -1184,7 +1184,7 @@

 @deftogether[(

 @defproc[(string->shell [str string?]) string?]

-@defproc[(shell->strings [str string?] [starts-exe? any/c #f]) list?]

+@defproc[(shell->strings [str string?] [starts-exe? any/c #f]) (listof string?)]

 )]{

 The @racket[string->shell] function converts a string to a

@@ -1245,11 +1245,11 @@

 @racket['dir], or @racket['link], with @racket['link] only on Unix and

 only when @racket[follow-links?] is @racket[#f].}

-@defproc[(ls [dir path-string?]) list?]{

+@defproc[(ls [dir path-string?]) (listof path-string?)]{

 Returns a list of path strings for files in @racket[dir].}

-@defproc[(ls* [dir path-string?]) list?]{

+@defproc[(ls* [dir path-string?]) (listof path-string?)]{

 Like @racket[ls], but builds a path using @racket[dir] for each

 element of the result list.}

@@ -1306,7 +1306,7 @@

 inclusive; if @racket['mode] is not provided, the mode of

 @racket[source] is used. The creation-time mode can be modified by

 the process's umask, but unless @racket[options] maps

-@racket['replace-mode] to @racket[#false], the mode is explicitly applied again

+@racket['replace-mode] to @racket[#f], the mode is explicitly applied again

 to @racket[destination]---whether @racket[destination] was just

 created or exists already, and ignoring the process's umask. On

 Windows, the attributes of @racket[source] are always copied to

@@ -1315,7 +1315,7 @@

 value and @racket[2] is @racket[0].

 The @racket[:no-replace-mode] hash table maps

-@racket['no-replace-mode] to @racket[#true].

+@racket['replace-mode] to @racket[#f].

 @history[#:changed "1.6" @elem{Added the @racket[options] argument and

                                @racket[:no-replace-mode].}]}

@@ -1331,9 +1331,9 @@

 @history[#:changed "1.6" @elem{Added the @racket[options] argument.}]}

 @deftogether[(

-@defproc[(file-exists? [name path-string?]) booelan?]

-@defproc[(directory-exists? [name path-string?]) booelan?]

-@defproc[(link-exists? [name path-string?]) booelan?]

+@defproc[(file-exists? [name path-string?]) boolean?]

+@defproc[(directory-exists? [name path-string?]) boolean?]

+@defproc[(link-exists? [name path-string?]) boolean?]

 )]{

 Uses @racket[stat] to check for a file, directory, or link,

@@ -1371,11 +1371,11 @@

       is determined by the compiler used to build the Zuo executable,

       but it can be set explicitly by defining either the

       @tt{ZUO_WINDOWS_TOOLCHAIN} or @tt{ZUO_UNIX_TOOLCHAIN}

-      preprocessor symbol when compiliing Zuo}

+      preprocessor symbol when compiling Zuo}

 @item{@racket['sys-dir] (Windows only): the path to the system directory}

-@item{@racket['can-exec?]: a boolean whether @racket[process] supports

+@item{@racket['can-exec?]: a boolean indicating whether @racket[process] supports

       a true value for the @racket['exec?] option}

 @item{@racket['version]: Zuo's major version number as an integer}

@@ -1402,7 +1402,7 @@

 This function is intended to be used after some set of modules has

 been loaded, so that the loaded modules are included in the image. The

-dump fails if if any @tech{handle} is encountered as reachable from

+dump fails if any @tech{handle} is encountered as reachable from

 loaded modules, however.}

 @defproc[(exit [status integer? 0]) void?]{

--- a/zuo-doc/overview.scrbl

+++ b/zuo-doc/overview.scrbl

@@ -133,7 +133,7 @@

  @item{booleans;}

- @item{integers as 64-bit two's complement with modular arithmetic}

+ @item{integers as 64-bit two's complement with modular arithmetic;}

  @item{strings as byte strings (optionally prefixed with @litchar{#}

        and with @litchar{\n}, @litchar{\r}, @litchar{\t},

@@ -257,7 +257,7 @@

 A call @racket[(module->hash _M)] primitive checks whether the module

 @racket[_M] is already loaded and returns its hash table if so. The

-@racket[zuo/kernel] module is always preloaded, but other modules may

+@racketmodname[zuo/kernel] module is always preloaded, but other modules may

 be preloaded in an image that was created by

 @racket[dump-image-and-exit]. If a module @racket[_M] is not already

 loaded, @racket[module->hash] reads the beginning of @racket[_M]'s

--- a/zuo-doc/zuo-build.scrbl

+++ b/zuo-doc/zuo-build.scrbl

@@ -87,7 +87,7 @@

 @section[#:tag "make-target"]{Creating Targets}

 Construct a @deftech{target} with either @racket[input-file-target]

-(given a file name), @racket[input-data-target] (given a value whose

+(given a filename), @racket[input-data-target] (given a value whose

 @racket[~s] form is hashed), or @racket[target] (given a filename for a

 real target or a symbol for a @tech{phony} target).

@@ -106,9 +106,9 @@

 When a target's @racket[_rebuild] function is called, it optionally

 returns a hash for the result of the build if the target's

-@racket[rule] had one, otherwise @racket[file-sha256] is used to get a

+@racket[rule] has one, otherwise @racket[file-sha256] is used to get a

 result hash. Either way, it's possible that the result hash is the

-same the one returned by @racket[_get-rule]; that is, maybe a

+same as the one returned by @racket[_get-rule]; that is, maybe a

 dependency of the target changed, but the change turned out not to

 affect the built result. In that case, rebuilding for other targets

 that depend on this one can be short-circuited.

@@ -143,13 +143,13 @@

 There is no global list of targets that @racket[build] draws from.

 Instead, @racket[build] starts with a given target, and it learns

-about other targets a @racket[_get-dep] procedures return them and as

+about other targets as @racket[_get-dep] procedures return them and as

 @racket[_rebuild] procedures expose them via @racket[build/dep]. If

 @racket[build] discovers multiple non-input targets with the same

 filename, then it reports an error.

 The @racket[build/command-line] function is a convenience to implement

-get @exec{make}-like command-line handling for building targets. The

+@exec{make}-like command-line handling for building targets. The

 @racket[build/command-line] procedure takes a list of targets, and it

 calls @racket[build] on one or more of them based on command-line

 arguments (with help from @racket[find-target]).

@@ -203,7 +203,7 @@

 if @filepath{Mf-config} is written in the same directory with a

 @litchar{srcdir=} line to specify the source directory (where no

 escapes are needed for the path after @litchar{=}), then a

-@filepath{mzin.zuo} of them form

+@filepath{main.zuo} of the form

 @racketblock[

 @#,hash-lang[] @#,racketmodname[zuo]

@@ -244,7 +244,7 @@

 A build runs in a @tech{threading context}, so a target's

 @racket[_get-deps] or @racket[_rebuild] procedure can use

-@racket[thread-process-wait] can be used to wait on a process. Doing

+@racket[thread-process-wait] to wait on a process. Doing

 so can enable parallelism among targets, depending on the

 @racket['jobs] option provided to @racket[build] or

 @racket[build/command-line], a @DFlag{jobs} command-line argument

@@ -367,7 +367,7 @@

 @item{@racket['db-dir] mapped to a path or @racket[#f]: if

       non-@racket[#f], build information for the target is stored in

       @filepath{_zuo.db} and @filepath{_zuo_tc.db} files in the

-      specified directory, instead of the directory of @racket[path].}

+      specified directory, instead of the directory of @racket[name].}

 ]}

@@ -469,7 +469,7 @@

 Like @racket[build], but continues a build in progress as represented

 by a @racket[token] that was passed to a target's @racket[_get-deps]

 or @racket[_rebuild] procedure. Targets reachable through

-@racket[target] may have been built or have be in progress already,

+@racket[target] may have been built or have been in progress already,

 for example. After @racket[target] is built, it is registered as a

 dependency of the target that received @racket[token] (if the target

 is not @tech{phony}).}

@@ -491,12 +491,13 @@

 If @racket[options] has a mapping for @racket['args], the value is

 used as the command-line arguments to parse instead of

-@racket[(hash-ref (system-env) 'args)]. If @racket[options] has a

+@racket[(hash-ref (runtime-env) 'args)]. If @racket[options] has a

 mapping for @racket['usage], the value is used as the usage options

 string.}

-@defproc[(build/command-line* [targets-at (procedure? hash? . -> . (listof target?))]

+@defproc[(build/command-line* [targets-at ((path-string? ... . -> . path-string?) hash?

+                                           . -> . (listof target?))]

                               [at-dir (path-string? ... . -> . path-string?) (make-at-dir ".")]

                               [options hash? (hash)])

          void?]{

@@ -509,27 +510,27 @@

 not starting @litchar{0}-@litchar{9}. These variables can appear

 anywhere in the command line and are removed from the argument list

 sent on to @racket[build/command-line], but no argument after a

-@racket{--} argument is parsed as a variable assignment.

+@litchar{--} argument is parsed as a variable assignment.

 The @racket[targets-at] procedure is applied to @racket[at-dir] and a

 hash table of variables, where each variable name is converted to a

-symbol and the value is left exact as after @litchar{=}.}

+symbol and the value is left exactly as after @litchar{=}.}

 @defproc[(find-target [name string?]

                       [targets (listof target?)]

-                      [fail-k procedure? (lambda () (error ....))])

+                      [fail-k (-> any/c) (lambda () (error ....))])

          (or/c target? #f)]{

 Finds the first target in @racket[targets] that is a match for

 @racket[name], returning @racket[#f] is not match is found. A

-@racket[name] matches when it is the same as n entire symbol or path

+@racket[name] matches when it is the same as an entire symbol or path

 target name or when it matches a suffix that is preceded by

 @litchar{/} or @litchar{\\}. If no match is found, @racket[fail-k]

 is called in tail position.}

-@defproc[(make-at-dir [path path-string?]) (path-string?  ... . -> . path-string?)]{

+@defproc[(make-at-dir [path path-string?]) (path-string? ... . -> . path-string?)]{

-Creates a function that is similar to on created by @racket[at-source],

+Creates a function that is similar to one created by @racket[at-source],

 but relative to @racket[path].}

 @deftogether[(

@@ -546,7 +547,7 @@

 @deftogether[(

 @defproc[(file-sha256 [file path-string?] [token (or/c token? #f)]) sha256?]

-@defproc[(sha256? [v any/c]) booelan?]

+@defproc[(sha256? [v any/c]) boolean?]

 @defthing[sha256-length integer? #:value 64]

 )]{

@@ -607,7 +608,7 @@

                        at-source)

 ]}

-@defproc[(make-targets [specs list?]) list?]{

+@defproc[(make-targets [specs list?]) (listof target?)]{

 Converts a @exec{make}-like specification into a list of targets for use

 with @racket[build]. In this @exec{make}-like specification, extra

--- a/zuo-doc/zuo-lib.scrbl

+++ b/zuo-doc/zuo-lib.scrbl

@@ -71,7 +71,7 @@

 @defzuomodule[zuo/glob]

-@defproc[(glob->matcher [glob string?]) procedure?]{

+@defproc[(glob->matcher [glob string?]) (string? . -> . boolean?)]{

 Creates a procedure that takes a string and reports @racket[#t] if the

 string matches the pattern @racket[glob], @racket[#f] otherwise.

@@ -124,7 +124,7 @@

 a time, where a thread switch happens only when a thread terminates or

 uses a (potentially) blocking operation.

-@defproc[(call-in-main-thread [thunk procedure]) any/c]{

+@defproc[(call-in-main-thread [thunk (-> any/c)]) any/c]{

 Creates a new @tech{threading context}, calling @racket[thunk] in the

 main thread of the context, and returning the value of @racket[thunk]

@@ -133,7 +133,7 @@

 thread is blocked on a channel.}

 @deftogether[(

-@defproc[(thread [thunk procedure?]) thread?]

+@defproc[(thread [thunk (-> any/c)]) thread?]

 @defproc[(thread? [v any/c]) boolean?]

 @defproc[(channel) channel?]

 @defproc[(channel? [v any/c]) boolean?]

@@ -350,7 +350,7 @@

 @history[#:added "1.1"]

-@defproc[(maybe-jobserver-client) (or/c procedure? #f)]{

+@defproc[(maybe-jobserver-client) (or/c ((or/c 'get 'put) . -> . void?) #f)]{

 Returns a procedure if a jobserver configuration is found via the

 @envvar{MAKEFLAGS} environment variable, @racket[#f] otherwise. That