In R, how can I create a function that can take values from columns using dplyr::mutate, but also still take specific strings as values?

This is probably a poorly worded question, but bear with me.

I'm trying to make a function in R that converts values based on user-supplied units as strings. Here's a simplified version:

conv <- function(val, from, to){
  if(from == "g" & to == "kg"){
    return(val / 1000)
  }else if(from == "kg" & to == "g"){
    return(val * 1000)
  }
}

So far, so good. As long as I specifically provide units, it works fine:

> conv(val = 10, from = "g", to = "kg")
[1] 0.01

However, I would also like to be able to use this to convert values in a data frame where I don't know the units beforehand. Instead, the units would come from columns in the data frame.

Let's say I have the following data frame:

library(dplyr)

df <- tibble(VAL = round(runif(n = 10, min = 5, max = 50), 0),
             FROM = sample(c("g", "kg"), size = 10, replace = TRUE),
             TO = sample(c("g", "kg"), size = 10, replace = TRUE))

Here, the units can change so I can't specify them in the function. But if I just run my function via dplyr::mutate, I get an error:

df_conv <- df |>
+   mutate(VAL_CONV = conv(val = VAL, from = FROM, to = TO))

Error in `mutate()`:
ℹ In argument: `VAL_CONV = conv(val = VAL, from = FROM, to = TO)`.
Caused by error in `if (from == "g" & to == "kg") ...`:
! the condition has length > 1

How can I write a function so that it can take values the user types in directly, but also take values provided in columns via mutate?

I'd like to keep the solution in base R, but not totally necessary.

You can try dplyr::case_when

library(dplyr)

conv <- function(val, from, to){
  case_when(from == "g" & to == "kg" ~ val / 1000,
            from == "kg" & to == "g" ~ val * 1000,
            .default = val)
}

Or in base R, nested ifelse:

conv <- function(val, from, to){
  ifelse(from == "g" & to == "kg", val / 1000,
            ifelse(from == "kg" & to == "g", val * 1000, val))
}

Both case_when and ifelse give the same results on your test case, but case_when would be much more readable when you have multiple conditions.

In mutate:

df |> mutate(VAL_CONV = conv(val = VAL, from = FROM, to = TO))
#> # A tibble: 10 × 4
#>      VAL FROM  TO     VAL_CONV
#>    <dbl> <chr> <chr>     <dbl>
#>  1    17 kg    kg       17    
#>  2    45 kg    kg       45    
#>  3    27 kg    g     27000    
#>  4    30 g     kg        0.03 
#>  5    34 g     kg        0.034
#>  6    47 g     kg        0.047
#>  7    48 kg    g     48000    
#>  8    44 g     g        44    
#>  9    19 g     g        19    
#> 10    24 kg    g     24000

Take user input:

conv(val = 10, from = "g", to = "kg")
#> [1] 0.01

I think you have to either put a functional in your function or in the mutate call in your pipe. For the first, you can change your function the following:

conv <- function(val, from, to){
  Map(\(val, from, to) {
    if (from == "g" & to == "kg"){
      return(val / 1000)
    } else if (from == "kg" & to == "g"){
      return(val * 1000)
    } else { # handles problems with example when from/to are the same
      return(NA_real_)
    }
  }, 
  val, from, to
  ) 
}

mutate(df, new = conv(VAL, FROM, TO))

The problem with this is that it returns lists, but is a base R solution. I'd suggest using purrr::pmap_dbl instead:

conv <- function(val, from, to) {
  purrr::pmap_dbl(
    list(val, from, to), 
    \(val, from, to) {
      if (from == "g" & to == "kg") {
        return(val / 1000)
      } else if (from == "kg" & to == "g") {
        return(val * 1000)
      } else {
        return(NA_real_)
      }
    }
  ) 
}

Finally, you can leave your function as is and do something like this:

conv2 <- function(val, from, to){
  if(from == "g" & to == "kg"){
    return(val / 1000)
  }else if(from == "kg" & to == "g"){
    return(val * 1000)
  } else {
    return(NA_real_)
  }
}

df <- tibble(VAL = round(runif(n = 10, min = 5, max = 50), 0),
             FROM = sample(c("g", "kg"), size = 10, replace = TRUE),
             TO = sample(c("g", "kg"), size = 10, replace = TRUE)) |> 
  rowwise() |> 
  mutate(new = pmap_dbl(list(VAL, FROM, TO), conv2))