Introduces optional types with some() and none, as well as match_with() from functional languages.
You can install this package from this repository by running
devtools::install_github("antoinechampion/optional"), or from the CRAN by running
This package adds an
optional type, similar to
Option in F#, OCaml and Scala, to
Maybe in Haskell, and to nullable types in
It should be used instead of
NULL for values that might be missing or otherwise invalid.
This package also introduces pattern matching.
optional is an object wrapper which indicates whether the object is valid or not.
An optional variable can be set to
some(object) or to
a <- some(5) class(a)
##  "optional"
Operators and print will have the same behavior with an
optional than with its base type.
a == 5
##  TRUE
##  5
some(obj) and that
Given a function
f(), to handle properly
optional arguments and wraps its return type into an
optional, one should use
make_opt() the following way:
f_opt <- make_opt(f)
optionalargument passed to
f_opt()will be converted to its original type before being sent to
f(). If one or more of them is
none, several behaviors are available (see
f()returns null, or if an error is thrown during its execution, then
none. Else it will return
c_opt <- make_opt(c) c_opt(some(2), none, some(5))
##  2 5
##  "None"
Patterns are used in many functional languages in order to process variables in an exhaustive way.
The syntax is the following:
match_with( variable, pattern , result-function, ...
variable matches a
result-function is called. For comparing optional types, it is a better habit to use
match_with() rather than a conditional statement.
a <- 5 match_with(a, . %>% some(.), paste, none, function() "Error!" )
##  "5"
patterncan be either:
variableis in the list),
magrittrfunctional sequence that matches if it returns
variable. The dot
.denotes the variable to be matched.
result-functiontakes no arguments, it will be called as is. Else, the only argument that will be sent is
variable. You can also use the fallthrough function
fallthrough()to permit the matching to continue even if the current pattern is matched.
a <- 4 match_with(a, 1, function() "Matched exact value", list(2, 3, 4), fallthrough(function() "Matched in list"), . %>% if (. > 3)., function(x) paste0("Matched in condition: ",x,">3") )
##  "Matched in list" "Matched in condition: 4>3"
match_with()now returns a concatenation of return values from matched result-functions
match_with()are now direct object comparisons instead of near equality checks