Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://docs.racket-lang.org/reference/Reading.html below:

13.4 Reading

Reads and returns a single

from

. If

has a handler associated to it via

, then the handler is called. Otherwise, the default reader is used, as parameterized by the

parameter, as well as many other parameters.

See The Reader for information on the default reader and Reading via an Extension for the protocol of read.

Like

, but produces a

with source-location information. The

is used as the source field of the syntax object; it can be an arbitrary value, but it should generally be a path for the source file.

See The Reader for information on the default reader in read-syntax mode and Reading via an Extension for the protocol of read-syntax.

Typically, line counting should be enabled for in so that source locations in syntax objects are in characters, instead of bytes. See also Counting Positions, Lines, and Columns.

See also Syntax Objects in The Racket Guide.

Similar to calling

, but normally used during the dynamic extent of

within a reader-extension procedure (see

). The main effect of using

instead of

is that graph-structure annotations (see

) in the nested read are considered part of the overall read, at least when the

argument is true; since the result is wrapped in a placeholder, however, it is not directly inspectable.

If start is provided and not #f, it is effectively prefixed to the beginning of in’s stream for the read. (To prefix multiple characters, use input-port-append.)

The readtable argument is used for top-level parsing to satisfy the read request, including various delimiters of a built-in top-level form (such as parentheses and . for reading a hash table); recursive parsing within the read (e.g., to read the elements of a list) instead uses the current readtable as determined by the current-readtable parameter. A reader macro might call read/recursive with a character and readtable to effectively invoke the readtable’s behavior for the character. If readtable is #f, the default readtable is used for top-level parsing.

When graph? is #f, graph structure annotations in the read datum are local to the datum.

When called within the dynamic extent of read, the read/recursive procedure can produce a special-comment value (see Special Comments) when the input stream’s first non-whitespace content parses as a comment.

See Readtables for an extended example that uses read/recursive.

Changed in version 6.2 of package base: Adjusted use of readtable to more consistently apply to the delimiters of a built-in form.

Analogous to calling

, but the resulting value encapsulates S-expression structure with source-location information. As with

, when

is used within the dynamic extent of

, the result from

is either a special-comment value, end-of-file, or opaque graph-structure placeholder (not a syntax object). The placeholder can be embedded in an S-expression or syntax object returned by a reader macro, etc., and it will be replaced with the actual syntax object before the outermost

returns.

Using read/recursive within the dynamic extent of read-syntax does not allow graph structure for reading to be included in the outer read-syntax parsing, and neither does using read-syntax/recursive within the dynamic extent of read. In those cases, read/recursive and read-syntax/recursive produce results like read and read-syntax, except that a special-comment value is returned when the input stream starts with a comment (after whitespace).

See Readtables for an extended example that uses read-syntax/recursive.

Changed in version 6.2 of package base: Adjusted use of readtable in the same way as for read/recursive.

A reader language is specified by #lang or #! (see Reading via an Extension) at the beginning of the input, though possibly after comment forms. The default readtable is used by read-language (instead of the value of current-readtable), and #reader forms (which might produce comments) are not allowed before #lang or #!.

See also Source-Handling Configuration in The Racket Guide.

When it finds a #lang or #! specification, instead of dispatching to a read or read-syntax function as read and read-syntax do, read-language dispatches to the get-info function (if any) exported by the same module. The arguments to get-info are the same as for read as described in Reading via an Extension. The result of the get-info function is the result of read-language if it is a function of two arguments; if get-info produces any other kind of result, the exn:fail:contract exception is raised. If no get-info function is exported, read-language returns #f.

The function produced by

reflects information about the expected syntax of the input stream. The first argument to the function serves as a key on such information; acceptable keys and the interpretation of results is up to external tools, such as DrRacket (see

). If no information is available for a given key, the result should be the second argument.

Examples:

> (scribble-manual-info 'color-lexer #f)

#<procedure:scribble-inside-lexer>

> (scribble-manual-info 'something-else #f)

#f

The get-info function itself is applied to five arguments: the input port being read, the module path from which the get-info function was extracted, and the source line (positive exact integer or #f), column (non-negative exact integer or #f), and position (positive exact integer or #f) of the start of the #lang or #! form. The get-info function may further read from the given input port to determine its result, but it should read no further than necessary. The get-info function should not read from the port after returning a function.

If in starts with a reader language specification but the relevant module does not export get-info (but perhaps does export read and read-syntax), then the result of read-language is #f.

If in has a #lang or #! specification, but parsing and resolving the specification raises an exception, the exception is propagated by read-language. Having at least #l or #! (after comments and whitespace) counts as starting a #lang or #! specification.

If in does not specify a reader language with #lang or #!, then fail-thunk is called. The default fail-thunk raises exn:fail:read or exn:fail:read:eof.

A

that controls parsing and printing of symbols. When this parameter’s value is

, the reader case-folds symbols (e.g., producing

when the input is any one of

,

,

, or

). The parameter also affects the way that

prints symbols containing uppercase characters; if the parameter’s value is

, then symbols are printed with uppercase characters quoted by a

or

. The parameter’s value is overridden by quoting

or

vertical-bar quotes and the

and

prefixes; see

for more information. While a module is loaded, the parameter is set to

(see

).

A

that controls whether

and

are treated as parentheses, but the resulting list tagged with

. See

for more information.

Added in version 6.3.0.5 of package base.

A

that controls whether

and

are treated as parentheses, but the resulting list tagged with

. See

for more information.

Added in version 6.3.0.5 of package base.

Added in version 8.4.0.8 of package base.

A

that controls parsing input numbers with a decimal point or exponent (but no explicit exactness tag). See

for more information.

A

that controls parsing input numbers that have a

,

,

, or

precision character. See

for more information.

Added in version 7.3.0.5 of package base.

Added in version 6.3.0.5 of package base.

A parameter whose value determines a readtable that adjusts the parsing of S-expression input, where

implies the default behavior. See

for more information.

Using the default parameter values ensures consistency, and it also provides safety when reading from untrusted sources, since the default values disable evaluation of arbitrary code via #lang or #reader.

A parameter whose value converts or rejects (by raising an exception) a module-path datum following

. See

for more information.

A

that enables lazy parsing of compiled code, so that closure bodies and syntax objects are extracted (and validated) from marshaled compiled code on demand. Normally, this parameter is set by the default

when

is

.

A #f value for read-on-demand-source disables lazy parsing of compiled code. A #t value enables lazy parsing. A path value furthers enable lazy retrieval from disk—instead of keeping unparsed compiled code in memory—when the PLT_DELAY_FROM_ZO environment variable is set (to any value) on start-up.

If the file at mode as a path changes before the delayed code is parsed when lazy retrieval from disk is enabled, then the on-demand parse most likely will encounter garbage, leading to an exception.

A port read handler is applied to either one argument or two arguments:

• A single argument is supplied when the port is used with read; the argument is the port being read. The return value is the value that was read from the port (or end-of-file).

• Two arguments are supplied when the port is used with read-syntax; the first argument is the port being read, and the second argument is a value indicating the source. The return value is a syntax object that was read from the port (or end-of-file).

The default port read handler reads standard Racket expressions with Racket’s built-in parser (see The Reader). It handles a special result from a custom input port (see make-input-port) by treating it as a single expression, except that special-comment values (see Special Comments) are treated as whitespace.

The default port read handler itself can be customized through a readtable; see Readtables for more information.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4