deparse                 package:base                 R Documentation

Expression Deparsing

Description:

     Turn unevaluated expressions into character strings.

Usage:

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

Arguments:

    expr: any R expression.

width.cutoff: integer in [20, 500] determining the cutoff 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: 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.

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")

