# fcase

`fcase.Rd`

`fcase`

is a fast implementation of SQL `CASE WHEN`

statement for R. Conceptually, `fcase`

is a nested version of `fifelse`

(with smarter implementation than manual nesting). It is comparable to `dplyr::case_when`

and supports `bit64`

's `integer64`

and `nanotime`

classes.

## Arguments

- ...
A sequence consisting of logical condition (

`when`

)-resulting value (`value`

)*pairs*in the following order`when1, value1, when2, value2, ..., whenN, valueN`

. Logical conditions`when1, when2, ..., whenN`

must all have the same length, type and attributes. Each`value`

may either share length with`when`

or be length 1. Please see Examples section for further details.- default
Default return value,

`NA`

by default, for when all of the logical conditions`when1, when2, ..., whenN`

are`FALSE`

or missing for some entries.

## Details

`fcase`

evaluates each when-value pair in order, until it finds a `when`

that is `TRUE`

. It then returns the corresponding `value`

. During evaluation, `value`

will be evaluated regardless of whether the corresponding `when`

is `TRUE`

or not, which means recursive calls should be placed in the last when-value pair, see `Examples`

.

`default`

is always evaluated, regardless of whether it is returned or not.

## Value

Vector with the same length as the logical conditions (`when`

) in `...`

, filled with the corresponding values (`value`

) from `...`

, or eventually `default`

. Attributes of output values `value1, value2, ...valueN`

in `...`

are preserved.

## Examples

```
x = 1:10
fcase(
x < 5L, 1L,
x > 5L, 3L
)
#> [1] 1 1 1 1 NA 3 3 3 3 3
fcase(
x < 5L, 1L:10L,
x > 5L, 3L:12L
)
#> [1] 1 2 3 4 NA 8 9 10 11 12
# Lazy evaluation example
fcase(
x < 5L, 1L,
x >= 5L, 3L,
x == 5L, stop("provided value is an unexpected one!")
)
#> [1] 1 1 1 1 3 3 3 3 3 3
# fcase preserves attributes, example with dates
fcase(
x < 5L, as.Date("2019-10-11"),
x > 5L, as.Date("2019-10-14")
)
#> [1] "2019-10-11" "2019-10-11" "2019-10-11" "2019-10-11" NA
#> [6] "2019-10-14" "2019-10-14" "2019-10-14" "2019-10-14" "2019-10-14"
# fcase example with factor; note the matching levels
fcase(
x < 5L, factor("a", levels=letters[1:3]),
x > 5L, factor("b", levels=letters[1:3])
)
#> [1] a a a a <NA> b b b b b
#> Levels: a b c
# Example of using the 'default' argument
fcase(
x < 5L, 1L,
x > 5L, 3L,
default = 5L
)
#> [1] 1 1 1 1 5 3 3 3 3 3
# fcase can be used for recursion, unlike fifelse
# Recursive function to calculate the Greatest Common Divisor
gcd_dt = function(x,y) {
r = x%%y
fcase(!r, y, r, gcd_dt(x, y)) # Recursive call must be in the last when-value pair
}
gcd_dt(10L, 1L)
#> [1] 1
```