recover                package:utils                R Documentation

_B_r_o_w_s_i_n_g _a_f_t_e_r _a_n _E_r_r_o_r

_D_e_s_c_r_i_p_t_i_o_n:

     This function allows the user to browse directly on any of the
     currently active function calls, and is suitable as an error
     option. The expression 'options(error=recover)' will make this the
     error option.

_U_s_a_g_e:

     recover()

_D_e_t_a_i_l_s:

     When called, 'recover' prints the list of current calls, and
     prompts the user to select one of them.  The standard R 'browser'
     is then invoked from the corresponding environment; the user can
     type ordinary S language expressions to be evaluated in that
     environment.

     When finished browsing in this call, type 'c' to return to
     'recover' from the browser.  Type another frame number to browse
     some more, or type '0' to exit 'recover'.

     The use of 'recover' largely supersedes 'dump.frames' as an error
     option, unless you really want to wait to look at the error.  If
     'recover' is called in non-interactive mode, it behaves like
     'dump.frames'.  For computations involving large amounts of data,
     'recover' has the advantage that it does not need to copy out all
     the environments in order to browse in them.  If you do decide to
     quit interactive debugging, call 'dump.frames' directly while
     browsing in any frame (see the examples).

     _WARNING_: The special 'Q' command to go directly from the browser
     to the prompt level of the evaluator currently interacts with
     'recover' to effectively turn off the error option for the next
     error (on subsequent errors, 'recover' will be called normally).

_V_a_l_u_e:

     Nothing useful is returned.  However, you _can_ invoke 'recover'
     directly from a function, rather than through the error option
     shown in the examples.  In this case, execution continues after
     you type '0' to exit 'recover'.

_C_o_m_p_a_t_i_b_i_l_i_t_y _N_o_t_e:

     The R 'recover' function can be used in the same way as the S-Plus
     function of the same name; therefore, the error option shown is a
     compatible way to specify the error action.  However, the actual
     functions are essentially unrelated and interact quite differently
     with the user.  The navigating commands 'up' and 'down' do not
     exist in the R version; instead, exit the browser and select
     another frame.

_R_e_f_e_r_e_n_c_e_s:

     John M. Chambers (1998). _Programming with Data_; Springer. 
      See the compatibility note above, however.

_S_e_e _A_l_s_o:

     'browser' for details about the interactive computations;
     'options' for setting the error option; 'dump.frames' to save the
     current environments for later debugging.

_E_x_a_m_p_l_e_s:

     ## Not run: 

     options(error = recover) # setting the error option

     ### Example of interaction

     > myFit <- lm(y ~ x, data = xy, weights = w)
     Error in lm.wfit(x, y, w, offset = offset, ...) :
             missing or negative weights not allowed

     Enter a frame number, or 0 to exit
     1:lm(y ~ x, data = xy, weights = w)
     2:lm.wfit(x, y, w, offset = offset, ...)
     Selection: 2
     Called from: eval(expr, envir, enclos)
     Browse[1]> objects() # all the objects in this frame
     [1] "method" "n"      "ny"     "offset" "tol"    "w"
     [7] "x"      "y"
     Browse[1]> w
     [1] -0.5013844  1.3112515  0.2939348 -0.8983705 -0.1538642
     [6] -0.9772989  0.7888790 -0.1919154 -0.3026882
     Browse[1]> dump.frames() # save for offline debugging
     Browse[1]> c # exit the browser

     Enter a frame number, or 0 to exit
     1:lm(y ~ x, data = xy, weights = w)
     2:lm.wfit(x, y, w, offset = offset, ...)
     Selection: 0 # exit recover
     >

     ## End(Not run)

