Quit and restart a clean R session from within R?

Question

Is there a way I can make an alias, within R, that will execute q() and then restart a clean R session?

And yes, I am too lazy to type q() and then the letter R :)

Answer 1

If you're in RStudio: command/ctrl + shift + F10

You can also use

.rs.restartR()

Answer 2

Depending on how you start R try placing one of these lines into your .Rprofile file:

makeActiveBinding("refresh", function() { shell("Rgui"); q("no") }, .GlobalEnv)

makeActiveBinding("refresh", function() { system("R"); q("no") }, .GlobalEnv)

Then entering this into the R console:

refresh

will shut down the current session and start up a new one.

Answer 3

I found that .rs.restartR() works similar to pressing ctrl+shift+F10. but dose not unload the packages

Answer 4

As another alternative, Emacs ESS (>= 16.10) can reload the inferior R process via inferior-ess-r-reload-hook which is bound to C-c C-e C-r by default.

Answer 5

Old post, but none of the answers quite work (for me, I'm using Windows, haven't tested others), so I'll add my solution. Some of my terminology might be off here, but this should get the point across:

Above answers don't quite work

Most of the answers submitted here involve using shell or system which doesn't quite work because while they open a new R console and do instruct the original console to close, the new console is a process running in the application context of the old console. That means the original console cannot close until the new console closes. Some of the users above such as hedgedandlevered reported that closing the original console forces the new console to close. When I try, the new console does open, but the old console remains open in a frozen state until the new console is closed.

The basic problem is calling shell or system does not change the application context from the original console to the new one, and therefore the original process cannot terminate until the new console closes.

Alternative that works for me

Instead use shell.exec which would normally be used to open a file in the default application based on file type. When used on a .exe, apparently, it runs the executable. The important difference, though, is that the system starts the application in it's own separate context. So here's the code that works for me:

makeActiveBinding("restart.R", function() { shell.exec(paste0(R.home(),"/bin/x64/Rgui.exe")); q("no") }, .GlobalEnv)

You'll need to edit the file path /bin/x64/Rgui.exe to match whatever you use to start R. You just put this line in your .Rprofile file, then you can call it by entering restart.R in your R code.

The downside of this over other methods is that you can't pass command line arguments like --no-save as you would with just shell, but at least this will let you close out the original R process.

Answer 6

After looking for a solution to this, I solved my problem based on this solution here, using the R Package RDCOMClient.
The solution bellow just work within RStudio (Windows), once it simulates the keypresses ctrl+ shift + F10.

The RDCOMClient package must be installed with the command bellow:

install.packages("RDCOMClient", repos = "http://www.omegahat.net/R")

The code to simulate the keypresses within RStudio (Windows 10) are:

library(RDCOMClient) 
wsh <- COMCreate("Wscript.Shell") 
wsh$SendKeys("^+{F10}") 

In the last line in the code above, the 'ctrl' key is represented by '^' and the shift key by '+'. All the explanations for this key representaions are available here.

Just after running the last line of the code above, the whole R session in RStudio will be reset, according to @steadyfish's comment. That is, it removes all the data from current session and unload all the loaded packages in the session.

Answer 7

Write this function in your .Rprofile

r <- function() {
  assign('.Last',  function() {system('R')}, envir = globalenv())
  quit(save = 'no')
}

r() restarts you R session. Loaded packages will not reload. Your environment wont be saved.

Works for Linux. No idea of what may happen on other OS

Answer 8

I needed the same refresh session functionality on windows and I ended up with a slightly modified version of the code:

makeActiveBinding("refresh", function() { shell(paste0("start \"\" \"", R.home(), "/bin/x64/Rgui.exe\"")); q("no") }, .GlobalEnv)

On windows you need to modify the Rprofile.site file. It is under R's etc directory. Also watch out for the last part of the path the bin/x64 can change according to your system configuration. I hope this will help others too.

Answer 9

In line with Martin Morgan's idea of using .Last(); this restarts R with the same set of command-line options as previously called:

restart_r <- function(status = 0, debug = TRUE) {
  if (debug) message("restart_r(): Customizing .Last() to relaunch R ...")
  assign(".Last", function() {
    args <- commandArgs()
    system2(args[1], args = args[-1])
  }, envir = globalenv())   
  if (debug) message("restart_r(): Quitting current R session and starting a new one ...")
  quit(save = "no", status = status, runLast = TRUE)
}

Answer 10

I think, one realizes the best use of R by setting a current working directory in options. Then whenever your workspace /session file starts showing you up or has enough of your work in it (in between projects) you can just rename this default session file in the working directory after closing R and R/Rstudio will automatically start you in a new workspace/session file, without disturbing your current work.

Remember to quit R and rename the current session file

Of course if you do not want to save the current work you have to make sure you reset objects or operations on them were done after copying from original objects so they are as is. Trust me, knowing you can always load the old workspaces is a temptation but is more useful than not.

In short quit R, it gives you some gap while quitting means this workspace is full, rename it after completing the quit and restart R/Rstudio with a fresh workspace. You can always load select objects in the new workspace. Ideally all important work should be in Project directories but you still need a history of your jobs to go back to at times and saved sessions come in useful at some point once you are on longer projects. If you don't need any of it just rm(list=ls())

Also, I like the RDComClient idea by @Eduardo Alvin but it has been discontinued.

ALTERNATIVE OPTION

A simple alternative to get rid of the baggage at any time inside your workspace is to use save.image

save.image("Rstreamingscience.data")
quit(save='no')
load("Rstreamingscience.data") ##G:/ADA registers##
save.image("Rstreamingscience.data")

This leaves you free to come and go as you please and open as many workspaces as you need.

Answer 11

makeActiveBinding("refresh", function() { system(paste0(R.home(),"/bin/i386/R")); q("no") }, .GlobalEnv)

or with --save or --no-save

paste0(R.home(),"/bin/i386/R --no-save")

I think this is what you need if you've used setwd() before calling refresh (although neither this nor the original version works for me, since it restarts R then closes itself, a new window is never opened. If anyone can comment on this, please do so)

Answer 12

I have written the following function. Remember! You can only use it once, then you have to reload it after the R session restarts.

clc <- function() {
  rm(list = ls(envir = globalenv()),envir = globalenv()) #clear Vars from global enviroment
  gc()  #grabage colector
  cat("\014") #clc
  .rs.restartR() #clear session
}

Sometimes detaching a package also helps.