deparse {base} | R Documentation

## Expression Deparsing

### Description

Turn unevaluated expressions into character strings.

### Usage

    deparse(expr, width.cutoff = 60L,
            backtick = mode(expr) %in%
                c("call", "expression", "(", "function"),
            control = c("keepInteger", "showAttributes", "keepNA"),
            nlines = -1L)

### Arguments

`expr` | any R expression.
`width.cutoff` | integer in [20, 500] determining the cutoff (in bytes) at which line-breaking is tried.
`backtick` | logical indicating whether symbolic names should be enclosed in backticks if they do not follow the standard syntax.
`control` | character vector of deparsing options. See `.deparseOpts`.
`nlines` | integer: the maximum number of lines to produce. Negative values indicate no limit.

### Details

This function turns unevaluated expressions (where ‘expression’ is taken in a wider sense than the strict concept of a vector of mode `"expression"` used in `expression`) into character strings (a kind of inverse to `parse`).

A typical use of this is to create informative labels for data sets and plots. The example shows a simple use of this facility. It uses the functions `deparse` and `substitute` to create labels for a plot which are character string versions of the actual arguments to the function `myplot`.

The default for the `backtick` option is not to quote single symbols but only composite expressions. This is a compromise to avoid breaking existing code.

Using `control = "all"` comes closest to making `deparse()` an inverse of `parse()`. However, not all objects are deparse-able even with this option and a warning will be issued if the function recognizes that it is being asked to do the impossible.

Numeric and complex vectors are converted using 15 significant digits: see `as.character` for more details.

`width.cutoff` is a lower bound for the line lengths: deparsing a line proceeds until at least `width.cutoff` bytes have been output and e.g. `arg = value` expressions will not be split across lines.

### Note

To avoid the risk of a source attribute out of sync with the actual function definition, the source attribute of a function will never be deparsed as an attribute.

Deparsing internal structures may not be accurate: for example the graphics display list recorded by `recordPlot` is not intended to be deparsed and `.Internal` calls will be shown as primitive calls.

### References

Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The New S Language. Wadsworth & Brooks/Cole.

### See Also

`substitute`, `parse`, `expression`.

`Quotes` for quoting conventions, including backticks.

### Examples

    require(stats); require(graphics)

    deparse(args(lm))
    deparse(args(lm), width = 500)
    myplot <-
    function(x, y) {
        plot(x, y, xlab = deparse(substitute(x)),
            ylab = deparse(substitute(y)))
    }
    e <- quote(`foo bar`)
    deparse(e)
    deparse(e, backtick = TRUE)
    e <- quote(`foo bar`+1)
    deparse(e)
    deparse(e, control = "all")

[Package base version 3.3.0 Index]