

   CCoommppaaccttllyy DDiissppllaayy tthhee SSttrruuccttuurree ooff aann AArrbbiittrraarryy OObbjjeecctt

        str(object, ...)
        str.data.frame(object, ...)
        str.default(object, max.level = 0, vec.len = 4, digits.d = 3,
            give.attr = TRUE, give.length = TRUE,
            wid = .Options$width,
            nest.lev = 0,
            indent.str = paste(rep(" ", max(0, nest.lev + 1)), collapse = ".."))

        ls.str(name, pattern, mode = "any", max.level = 1, give.attr = FALSE)
        lsf.str(...)

   AArrgguummeennttss::

     object: any R object about which you want to have some
             information.

   max.level: maximal level of nesting which is applied for
             displaying nested structures, e.g., a list con-
             taining sub lists.  Default 0: Display all nesting
             levels.

    vec.len: numeric indicating how many ``first few'' elements
             are displayed of each vector. The number is multi-
             plied by different factors (from .5 to 3) depend-
             ing on the kind of vector.  Default 4.

   digits.d: number of digits for numerical components (as for
             `print').

   give.attr: logical; if `TRUE' (default), show attributes as
             sub structures.

   give.length: logical; if `TRUE' (default), indicate length
             (as `[1:...]').

        wid: the page width to be used.  The default is the
             currently active `options("width")'.

   nest.lev: current nesting level in the recursive calls to
             `str'.

   indent.str: the indentation string to use.

   DDeessccrriippttiioonn::

        This is a ``diagnostic'' function, and an alternative
        to `summary'.  Ideally, only one line for each
        ``basic'' structure is displayed.  It is especially
        well suited to compactly display the (abbreviated) con-
        tents of (possibly nested) lists.  The idea is to give
        reasonable output for any R object.  It calls `args'
        for (non-primitive) function objects.

        `ls.str' and `lsf.str' are useful ``versions'' of `ls',
        calling `str' on each object.  They are not foolproof
        and should rather not be used for programming, but are
        provided for their usefulness.

   VVaalluuee::

        Nothing, for efficiency reasons.  The obvious side
        effect is output to the terminal.

   AAuutthhoorr((ss))::

        Martin Maechler maechler@stat.math.ethz.ch since 1990.
        Currently at Seminar f"ur Statistik, ETH Z"urich,
        Switzerland.

   SSeeee AAllssoo::

        `summary', `args'.

   EExxaammpplleess::

        ## The following examples show some of `str' capabilities
        str(1:12)
        str(ls)
        str(args)#- more useful than  args(args) !
        data(freeny); str(freeny)
        str(str)
        str(.Machine, digits = 20)
        str( lsfit(1:9,1:9))
        str( lsfit(1:9,1:9),  max =1)
        op <- options(); str(op)#- save first; otherwise internal options() is used.
        need.dev <- !exists(".Device") || is.null(.Device)
        if(need.dev) postscript(); str(par()); if(need.dev) graphics.off()

        lsf.str()#- how do the functions look like which I am using?
        ls.str(mode = "list")#- what are the structured objects I have defined?

