Vrftsjtryk

You can create your own function:

`%:%` <- function(l, r) {

    intToUtf8(seq(utf8ToInt(l), utf8ToInt(r)), multiple = TRUE)

}

Usage:

"b" %:% "f"

# [1] "b" "c" "d" "e" "f"



"f" %:% "b"

# [1] "f" "e" "d" "c" "b"



"A" %:% "D"

# [1] "A" "B" "C" "D"

Another option with match, seq and do.call:

letters[do.call(seq, as.list(match(c("b","f"), letters)))]

which gives:

[1] "b" "c" "d" "e" "f"

Making a function of this such that it works with both lower-case and upper-case letters:

char_seq <- function(lets) {

  switch(all(grepl("[[:upper:]]", lets)) + 1L,

         letters[do.call(seq, as.list(match(lets, letters)))],

         LETTERS[do.call(seq, as.list(match(lets, LETTERS)))])

}

the output of this:

> char_seq(c("b","f"))

[1] "b" "c" "d" "e" "f"



> char_seq(c("B","F"))

[1] "B" "C" "D" "E" "F"

This function can be extended with checks on the correctness of the input:

char_seq <- function(lets) {

  g <- grepl("[[:upper:]]", lets)

  if(length(g) != 2) stop("Input is not of length 2")

  if(sum(g) == 1) stop("Input does not have all lower-case or all upper-case letters")

  switch(all(g) + 1L,

         letters[do.call(seq, as.list(match(lets, letters)))],

         LETTERS[do.call(seq, as.list(match(lets, LETTERS)))])

}

resulting in proper error-messages when the input is not correct:

> char_seq(c("B"))

Error in char_seq(c("B")) : Input is not of length 2



> char_seq(c("b","F"))

Error in char_seq(c("b", "F")) : 

  Input does not have all lower-case or all upper-case letters

Playing with UTF, something like:

intToUtf8(utf8ToInt("b"):utf8ToInt("f"), multiple = TRUE)

# [1] "b" "c" "d" "e" "f"

Perhaps using the raw versions of letters and then converting back to character could be used to define an infix function analogous to ":"

 `%c:%` <- function(x,y) { strsplit( rawToChar(as.raw(

     seq(as.numeric(charToRaw(x)), as.numeric(charToRaw(y))))), "" )[[1]]}

>  'a' %c:% 'g'

[1] "a" "b" "c" "d" "e" "f" "g"

I'm certainly not claiming this satisfies the request for "an easy way to do this" and I'm not even certain it would be more efficient, but it does introduce a couple of potentially useful functions.

Why not?

letters[which(letters == 'b') : which(letters == 'f')]

Iknow it is frowned upon, but here is an eval(parse(...)) solution

LETTERS[eval(parse(text = paste(which(LETTERS %in% c('B', 'F')), collapse = ':')))]

#[1] "B" "C" "D" "E" "F"

First things first: your code

which(letters %in% c("b", "f"))

Is a valid but convoluted way of writing

match(c('b', 'f'), letters)

(Why “convoluted”? Because %in% is a wrapper around match for a specific use-case, which explicitly turns the numeric index into a logical value, i.e. the inverse operation of which.)

Next, you can of course use the result and convert it into a range via idx[1L] : idx[2L] and there’s nothing wrong with that in this case. But R has an idiomatic way of expressing the concept of calling a function using a vector as its parameters: do.call:

do.call(`:`, as.list(match(c('b', 'f'), letters)))

Or, equivalently:

do.call(seq, as.list(match(c('b', 'f'), letters)))

{purrr} allows us to do the same without the as.list:

purrr::invoke(seq, match(c('b', 'f'), letters))

And, finally, we subset:

letters[purrr::invoke(seq, match(c('b', 'f'), letters))]