The hardware and bandwidth for this mirror is donated by METANET, the Webhosting and Full Service-Cloud Provider.
If you wish to report a bug, or if you are interested in having us mirror your free-software or open-source project, please feel free to contact us at mirror[@]metanet.ch.
Formal arguments of partial(..f, ...) no longer
record the original default values of ..f (since a
default-value expression may reference an argument that is fixed, and
therefore dropped, by partial()). Nevertheless, any default
values of ..f not overridden by partial()
remain in force when the function partial(..f, ...) is
called.
partial(..f, ...) can still fix arguments that match
the ... argument of ..f (if present), but only
when such arguments are specified by name.
compose(f, g)(x, y, ...) is now equivalent to a call
like (function(...) g(f(...)))(x, y, ...). (Previously, the
initial function was called with a complete set of formal arguments,
which in cases where formal arguments are mutated or mutually referenced
(e.g., in the formals of base::objects()), could lead the
initial function to wrongly determine the “missingness” of an argument
or wrongly evaluate an argument’s default value.) As before, the
signature of compose(f, ...) inherits the signature of
f.Gestalt now depends on a stable release of rlang, version 1.0.0 and
above. (A minor internal fix was made to address a change in the
behavior of rlang::is_expression().) There are no
user-facing changes.
%>>>% chain (e.g., the base-3 logarithm in
abs %>>>% log(base = 3)) is now properly captured.
Previously, it was erroneously matched to an rlang data mask, due to an
internal call to rlang::eval_tidy() using positional
arguments.%>>>% chain, a point (.) is
now only matched as an argument value when it is a symbol, not a
character (".") (#27).This is a maintenance release to fix test failures caused by changes in the rlang package.
The (minimum) required rlang version has been increased to 0.3.1.
This version fixed a bug which prevented certain operator “sections”
from being expressed. A chain like
`/`(2) %>>>% sin (halve and apply sine) now works
as expected.
Formals of primitive functions now agree with those of
base::args() (#18, #24). This means you can use
args() to determine the names of arguments when using
partial(). Thus, partial(`/`, e2 = 3) is the
same as partial(`/`, , 3) is the same as division-by-3.
Moreover, %>>>% chains are verified against the
argument names given by args(). Thus,
`/`(e2 = 2) %>>>% sin is valid, but
`/`(y = 2) %>>>% sin is invalid—`/`()
viewed as a closure has no argument called y.
Support for R 3.1 has been dropped.
Fixed a segfault caused by leakage of rlang internals (thanks @lionel-).
names() now gets the names of bindings in a context
(as made by let()).
posure() is a means of creating efficient
variable (i.e., parameterized) composite functions.
In particular, this addresses a shortcoming of the use of the
magrittr %>% in functions. Instead of writing
function(..., b = 2, n) {
sample(...) %>% log(base = b) %>% rep(n)
}which is inefficient because the function chain is created anew with each call, you can more directly curry it by writing
posure(b = 2, n ~ {
sample %>>>% log(base = b) %>>>% rep(n)
})Not only is the posure() version more succinct, it is
robuster and faster than the version with %>%, thanks to
the non-standard mechanism of a closure that is “partially dynamically
scoped.” (Whence the portmanteau “posure,” due to @henryaj; see the package documentation for
details.)
let() enables you to create
contexts: composable local environments in
which named expressions are lazily resolved in a given order.
Tidyverse quasiquotation of expressions is supported, allowing you to
exercise fine-grained control over the evaluation of
subexpressions.
As a companion to let(), run()
evaluates an expression relative to a context. Unlike
base::with(), run() supports quasiquotation
and provides a means of overriding bindings in a given context.
When calling a composite function, the point (.) in
an implicitly curried function may now assume any name (#10). This is
useful when you want to call the argument assumed by the point by its
original name, e.g., in a do.call() or
lapply() invocation.
partial() is now literally interpreted by
%>>>% (#11). For instance, you you can succinctly
write abs %>>>% partial(log, base = 2) instead of
abs %>>>% !!partial(log, base = 2).
In a composite function, default argument values following
... are no longer absorbed by ...
(#6).
Improvements to the documentation throughout.
Initial release.
fn() is extracted from nofrills 0.3.0.
These binaries (installable software) and packages are in development.
They may not be fully stable and should be used with caution. We make no claims about them.