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

Ileum

Well you can clear your workspace with rm(list=ls()) but thats not what you mean right? – Victoriavictorian

Do you also want to detach any packages and other things you may have attached? – Aiden

Perhaps one suggestion would be to add a new option save parameter to q(), such as "r", that restarts R without saving the workspace. Then an alias for q("r") could be assigned to a new function that restarts R. – Fourlegged

Answer 1

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

You can also use

.rs.restartR()

Libation

I believe opening a "clean R session" requires that 1-Data from current session is removed; 2-Packages from current session are unloaded. .rs.restartR() does not seem to do either of these things on my machine.. – Amr

I find the .rs.restartR() useful for cases where R wouldn't free up memory even after remove(list=ls()); gc();. This definitely frees up the memory. I also like the fact that it doesn't detach packages. – Tie

@RichardDiSalvo: But the question is: Does this help? As far as I understand, the not freed space is locked for R to work with it later, if needed. So if the space is needed afterwards, R can use it and does not need to demand memory again. Does it really speed up then? – Cupronickel

@lrgendniemand I think it might be helpful if you are trying to figure out if you're actually almost out of memory on your machine or if R is just holding on to memory. But I think there are probably better ways. – Tie

Answer 2

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

Clova

Works in RStudio - but I'm not sure there's a way to make it work anywhere else. From getAnywhere(".rs.restartR") it appears to be in tools:rstudio. I haven't had any luck accessing that in a pure R session. – Nigelniger

.rs.restartR() does not unload the packages, so it is not exactly the same as ctrl+shift+f10 – Dad

Note that .rs.restartR() reloads the objects and packages in the environment into the restarted session. – Hidalgo

Answer 3

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.

Adda

Works! brilliantly! – Sane

Answer 4

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.

Shavon

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.

Lancewood

Answer 6

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

Amil

Answer 7

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.

Lavona

Answer 8

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

Dare

FYI, I've added startup::restart() to the startup package as a convenint way of restart R. – Dare

Answer 9

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.

Ochs

Answer 10

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)

Upgrade

when I try this, a new window is opened, but the old window is kept open in a frozen state until the new window is closed – Lancewood

Answer 11

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.

Clova

Answer 12

If you're in Rstudio > 1.1.281, you can use:

install.packages("rstudioapi") # first time
rstudioapi::restartSession()

Haematite