Multiline Comment Workarounds?

I (sort of) already know the answer to this question. But I figured it is one that gets asked so frequently on the R Users list, that there should be one solid good answer. To the best of my knowledge there is no multiline comment functionality in R. So, does anyone have any good workarounds?

While quite a bit of work in R usually involves interactive sessions (which casts doubt on the need for multiline comments), there are times when I've had to send scripts to colleagues and classmates, much of which involves nontrivial blocks of code. And for people coming from other languages it is a fairly natural question.

In the past I've used quotes. Since strings support linebreaks, running an R script with

"
Here's my multiline comment.

"
a <- 10
rocknroll.lm <- lm(blah blah blah)
 ...

works fine. Does anyone have a better solution?

Solution 1:

You can do this easily in RStudio:

select the code and click CTR+SHIFT+C to comment/uncomment code.

Solution 2:

This does come up on the mailing list fairly regularly, see for example this recent thread on r-help. The consensus answer usually is the one shown above: that given that the language has no direct support, you have to either

• work with an editor that has region-to-comment commands, and most advanced R editors do
• use the if (FALSE) constructs suggested earlier but note that it still requires complete parsing and must hence be syntactically correct

Solution 3:

A neat trick for RStudio I've just discovered is to use #' as this creates an self-expanding comment section (when you return to new line from such a line or insert new lines into such a section it is automatically comment).

Solution 4:

[Update] Based on comments.

# An empty function for Comments
Comment <- function(`@Comments`) {invisible()}

#### Comments ####
Comment( `

  # Put anything in here except back-ticks.

  api_idea <- function() {
    return TRUE
  }

  # Just to show api_idea isn't really there...
  print( api_idea )

`)
####

#### Code. ####
foo <- function() {
  print( "The above did not evaluate!")
}
foo()

[Original Answer]

Here's another way... check out the pic at the bottom. Cut and paste the code block into RStudio.

Multiline comments that make using an IDE more effective are a "Good Thing", most IDEs or simple editors don't have highlighting of text within simple commented -out blocks; though some authors have taken the time to ensure parsing within here-strings. With R we don't have multi-line comments or here-strings either, but using invisible expressions in RStudio gives all that goodness.

As long as there aren't any backticks in the section desired to be used for a multiline comments, here-strings, or non-executed comment blocks then this might be something worth-while.

#### Intro Notes & Comments ####
invisible( expression( `
{ <= put the brace here to reset the auto indenting...

  Base <- function()
  {      <^~~~~~~~~~~~~~~~ Use the function as a header and nesting marker for the comments
         that show up in the jump-menu.
         --->8---
  }

  External <- function()
  {
    If we used a function similar to:
      api_idea <- function() {

        some_api_example <- function( nested ) {
          stopifnot( some required check here )
        }

        print("Cut and paste this into RStudio to see the code-chunk quick-jump structure.")
        return converted object
      }

    #### Code. ####
    ^~~~~~~~~~~~~~~~~~~~~~~~~~ <= Notice that this comment section isnt in the jump menu!
                                  Putting an apostrophe in isn't causes RStudio to parse as text
                                  and needs to be matched prior to nested structure working again.
    api_idea2 <- function() {

    } # That isn't in the jump-menu, but the one below is...

    api_idea3 <- function() {

    }

  }

    # Just to show api_idea isn't really there...
    print( api_idea )
    }`) )
####

#### Code. ####
foo <- function() {
  print( "The above did not evaluate and cause an error!")
}

foo()

## [1] "The above did not evaluate and cause an error!"

And here's the pic...

Solution 5:

I can think of two options. The first option is to use an editor that allows to block comment and uncomment (eg. Eclipse). The second option is to use an if statement. But that will only allow you to 'comment' correct R syntax. Hence a good editor is the prefered workaround.

if(FALSE){
     #everything in this case is not executed

}