head 1.13; access; symbols pkgsrc-2026Q1:1.12.0.4 pkgsrc-2026Q1-base:1.12 pkgsrc-2025Q4:1.12.0.2 pkgsrc-2025Q4-base:1.12 pkgsrc-2025Q3:1.11.0.14 pkgsrc-2025Q3-base:1.11 pkgsrc-2025Q2:1.11.0.12 pkgsrc-2025Q2-base:1.11 pkgsrc-2025Q1:1.11.0.10 pkgsrc-2025Q1-base:1.11 pkgsrc-2024Q4:1.11.0.8 pkgsrc-2024Q4-base:1.11 pkgsrc-2024Q3:1.11.0.6 pkgsrc-2024Q3-base:1.11 pkgsrc-2024Q2:1.11.0.4 pkgsrc-2024Q2-base:1.11 pkgsrc-2024Q1:1.11.0.2 pkgsrc-2024Q1-base:1.11 pkgsrc-2023Q4:1.9.0.6 pkgsrc-2023Q4-base:1.9 pkgsrc-2023Q3:1.9.0.4 pkgsrc-2023Q3-base:1.9 pkgsrc-2023Q2:1.9.0.2 pkgsrc-2023Q2-base:1.9 pkgsrc-2023Q1:1.8.0.2 pkgsrc-2023Q1-base:1.8 pkgsrc-2022Q4:1.7.0.2 pkgsrc-2022Q4-base:1.7 pkgsrc-2022Q3:1.6.0.4 pkgsrc-2022Q3-base:1.6 pkgsrc-2022Q2:1.6.0.2 pkgsrc-2022Q2-base:1.6 pkgsrc-2022Q1:1.5.0.6 pkgsrc-2022Q1-base:1.5 pkgsrc-2021Q4:1.5.0.4 pkgsrc-2021Q4-base:1.5 pkgsrc-2021Q3:1.5.0.2 pkgsrc-2021Q3-base:1.5 pkgsrc-2021Q2:1.4.0.2 pkgsrc-2021Q2-base:1.4 pkgsrc-2021Q1:1.3.0.6 pkgsrc-2021Q1-base:1.3 pkgsrc-2020Q4:1.3.0.4 pkgsrc-2020Q4-base:1.3 pkgsrc-2020Q3:1.3.0.2 pkgsrc-2020Q3-base:1.3 pkgsrc-2020Q2:1.2.0.8 pkgsrc-2020Q2-base:1.2 pkgsrc-2020Q1:1.2.0.4 pkgsrc-2020Q1-base:1.2 pkgsrc-2019Q4:1.2.0.6 pkgsrc-2019Q4-base:1.2 pkgsrc-2019Q3:1.2.0.2 pkgsrc-2019Q3-base:1.2; locks; strict; comment @# @; 1.13 date 2026.06.09.23.26.45; author mef; state Exp; branches; next 1.12; commitid lQ0x4ivjXzHXcbJG; 1.12 date 2025.09.27.09.57.27; author wiz; state Exp; branches; next 1.11; commitid GSXfRJoW2938VkcG; 1.11 date 2024.01.21.07.57.55; author mef; state Exp; branches; next 1.10; commitid clpBUkzbV5k82iVE; 1.10 date 2024.01.21.04.11.36; author mef; state Exp; branches; next 1.9; commitid XfyGEPRVJ84sMgVE; 1.9 date 2023.06.02.12.58.09; author mef; state Exp; branches; next 1.8; commitid 0Ofbsw5lyQNpbnrE; 1.8 date 2023.02.12.04.09.37; author mef; state Exp; branches; next 1.7; commitid O7W53YAFKReiNbdE; 1.7 date 2022.12.18.05.38.37; author mef; state Exp; branches; next 1.6; commitid vxBNM0f3XVAr506E; 1.6 date 2022.05.22.12.24.04; author mef; state Exp; branches; next 1.5; commitid uj4HFJIwwOg253FD; 1.5 date 2021.09.11.15.31.54; author mef; state Exp; branches; next 1.4; commitid pcfAT3FB4n2Jfy8D; 1.4 date 2021.06.12.22.36.14; author mef; state Exp; branches; next 1.3; commitid liKL9nF1zHqAwTWC; 1.3 date 2020.07.31.20.44.49; author brook; state Exp; branches; next 1.2; commitid HT3HnlAQqgv44hiC; 1.2 date 2019.09.25.17.26.38; author brook; state Exp; branches; next 1.1; commitid MK5Lm6j1yPYWVpEB; 1.1 date 2019.08.09.16.23.47; author brook; state Exp; branches; next ; commitid vPvgI6gl3f236nyB; desc @@ 1.13 log @(math/R-dplyr) Updated 1.1.4 to 1.2.1, fix build against R 4.6.0 # dplyr 1.2.1 * dplyr is now fully compliant with the R C API (#7819). # dplyr 1.2.0 ## New features * New `filter_out()` companion to `filter()`. * Use `filter()` when specifying rows to _keep_. * Use `filter_out()` when specifying rows to _drop_. `filter_out()` simplifies cases where you would have previously used a `filter()` to drop rows. It is particularly useful when missing values are involved. For example, to drop rows where the `count` is zero: ```r df |> filter(count != 0 | is.na(count)) df |> filter_out(count == 0) ``` With `filter()`, you must provide a "negative" condition of `!= 0` and must explicitly guard against accidentally dropping rows with `NA`. With `filter_out()`, you directly specify rows to drop and you don't have to guard against dropping rows with `NA`, which tends to result in much clearer code. This work is a result of [Tidyup 8: Expanding the `filter()` family](https://github.com/tidyverse/tidyups/pull/30), with a lot of great feedback from the community (#6560, #6891). * New `when_any()` and `when_all()`, which are elementwise versions of `any()` and `all()`. Alternatively, you can think of them as performing repeated `|` and `&` on any number of inputs, for example: * `when_any(x, y, z)` is equivalent to `x | y | z`. * `when_all(x, y, z)` is equivalent to `x & y & z`. `when_any()` is particularly useful within `filter()` and `filter_out()` to specify comma separated conditions combined with `|` rather than `&`, like: ```r # With `|` countries |> filter( (name %in% c("US", "CA") & between(score, 200, 300)) | (name %in% c("PR", "RU") & between(score, 100, 200)) ) # With `when_any()`, you drop the explicit `|`, the extra `()`, and your # conditions are all indented to the same level countries |> filter(when_any( name %in% c("US", "CA") & between(score, 200, 300), name %in% c("PR", "RU") & between(score, 100, 200) )) # To drop these rows instead, use `filter_out()` countries |> filter_out(when_any( name %in% c("US", "CA") & between(score, 200, 300), name %in% c("PR", "RU") & between(score, 100, 200) )) ``` This work is a result of [Tidyup 8: Expanding the `filter()` family](https://github.com/tidyverse/tidyups/pull/30). * `case_when()` is now part of a family of 4 related functions, 3 of which are new: * Use `case_when()` to create a new vector based on logical conditions. * Use `replace_when()` to update an existing vector based on logical conditions. * Use `recode_values()` to create a new vector by mapping all old values to new values. * Use `replace_values()` to update an existing vector by mapping some old values to new values. Learn all about these in a new vignette, `vignette("recoding-replacing")`. `replace_when()` is particularly useful for conditionally mutating rows within one or more columns, and can be thought of as an enhanced version of `base::replace()`. `recode_values()` and `replace_values()` have the familiar `case_when()`-style formula interface for easy interactive use, but also have `from` and `to` arguments as a way for you to incorporate a pre-built lookup table, making them more holistic replacements for both `case_match()` and `recode()`. This work is a result of [Tidyup 7: Recoding and replacing values in the tidyverse](https://github.com/tidyverse/tidyups/blob/main/007-tidyverse-recoding-and-replacing.md), with a lot of great [feedback](https://github.com/tidyverse/tidyups/pull/29) from the community (#7728, #7729). * `case_when()` has gained a new `.unmatched` argument. For extra safety, set `.unmatched = "error"` rather than providing a `.default` when you believe that you've handled every possible case, and it will error if a case is left unhandled. The new `recode_values()` also has this argument (#7653). * `if_else()`, `case_when()`, and `coalesce()` have gotten significantly faster and use much less memory due to a rewrite in C via vctrs (#7723, #7725, #7727). * New `ptype` argument for `between()`, allowing users to specify the desired output type. This is particularly useful for ordered factors and other complex types where the default common type behavior might not be ideal (#6906, @@JamesHWade). * New `rbind()` method for `rowwise_df` to avoid creating corrupt rowwise data frames (r-lib/vctrs#1935). ## Lifecycle changes ### Newly stable * `.by` has moved from experimental to stable (#7762). * `reframe()` has moved from experimental to stable (#7713, @@VisruthSK). ### Newly breaking * `if_else()` no longer allows `condition` to be a logical array. It must be a logical vector with no `dim` attribute (#7723). ### Newly deprecated * `case_match()` is soft-deprecated, and is fully replaced by `recode_values()` and `replace_values()`, which are more flexible, more powerful, and have much better names. * In `case_when()`, supplying all size 1 LHS inputs along with a size >1 RHS input is now soft-deprecated. This is an improper usage of `case_when()` that should instead be a series of if statements, like: ```r # Scalars! code <- 1L flavor <- "vanilla" # Improper usage: case_when( code == 1L && flavor == "chocolate" ~ x, code == 1L && flavor == "vanilla" ~ y, code == 2L && flavor == "vanilla" ~ z, .default = default ) # Recommended: if (code == 1L && flavor == "chocolate") { x } else if (code == 1L && flavor == "vanilla") { y } else if (code == 2L && flavor == "vanilla") { z } else { default } ``` The recycling behavior that allows this style of `case_when()` to work is unsafe, and can result in silent bugs that we'd like to guard against with an error in the future (#7082). * The `dplyr.legacy_locale` global option is soft-deprecated. If you used this to affect the ordering of `arrange()`, use `arrange(.locale =)` instead. If you used this to affect the ordering of `group_by() |> summarise()`, follow up with an additional call to `arrange(.locale =)` instead (#7760). * Passing `size` to `if_else()` is now deprecated. The output size is always taken from the `condition` (#7722). ### Other deprecation advancements * The following were already deprecated, and are now defunct and throw an error: * All underscored standard evaluation versions of major dplyr verbs. Deprecated in 0.7.0 (Jun 2017), use the non-underscored version of the verb with unquoting instead, see `vignette("programming")`. This includes: * `add_count_()` * `add_tally_()` * `arrange_()` * `count_()` * `distinct_()` * `do_()` * `filter_()` * `funs_()` * `group_by_()` * `group_indices_()` * `mutate_()` * `tally_()` * `transmute_()` * `rename_()` * `select_()` * `slice_()` * `summarise_()` * `summarize_()` * `mutate_each()`, `mutate_each_()`, `summarise_each()`, and `summarise_each_()`. Deprecated in 0.7.0 (Jun 2017), use `across()` instead. * Returning more or less than 1 row per group in `summarise()`. Deprecated in 1.1.0 (Jan 2023), use `reframe()` instead. * `combine()`. Deprecated in 1.0.0 (May 2020), use `c()` or `vctrs::vec_c()` instead. * `src_mysql()`, `src_postgres()`, `src_sqlite()`, `src_local()`, and `src_df()`. Deprecated in 1.0.0 (May 2020), use `tbl()` instead. * `tbl_df()` and `as.tbl()`. Deprecated in 1.0.0 (May 2020), use `tibble::as_tibble()` instead. * `add_rownames()`. Deprecated in 1.0.0 (May 2020), use `tibble::rownames_to_column()` instead. * The `.drop` argument of `add_count()`. Deprecated in 1.0.0 (May 2020), had no effect. * The `add` argument of `group_by()` and `group_by_prepare()`. Deprecated in 1.0.0 (May 2020), use `.add` instead. * The `.dots` argument of `group_by()` and `group_by_prepare()`. Deprecated in 1.0.0 (May 2020). * The `...` argument of `group_keys()` and `group_indices()`. Deprecated in 1.0.0 (May 2020), use `group_by()` first. * The `keep` argument of `group_map()`, `group_modify()`, and `group_split()`. Deprecated in 1.0.0 (May 2020), use `.keep` instead. * Using `across()` and data frames in `filter()`. Deprecated in 1.0.8 (Feb 2022), use `if_any()` or `if_all()` instead. * `multiple = NULL` in joins. Deprecated in 1.1.1 (Mar 2023), use `multiple = "all"` instead. * `multiple = "error" / "warning"` in joins. Deprecated in 1.1.1 (Mar 2023), use `relationship = "many-to-one"` instead. * The `vars` argument of `group_cols()`. Deprecated in 1.0.0 (Jan 2023). * The following were already deprecated, and now warn unconditionally if used: * `all_equal()`. Deprecated in 1.1.0 (Jan 2023), use `all.equal()` instead. * `progress_estimated()`. Deprecated in 1.0.0 (May 2020). * `filter()` with a 1 column matrix. Deprecated in 1.1.0 (Jan 2023), use a vector instead. * `slice()` with a 1 column matrix. Deprecated in 1.1.0 (Jan 2023), use a vector instead. * Not supplying the `.cols` argument of `across()`. Deprecated in 1.1.0 (Jan 2023). * `group_indices()` with no arguments. Deprecated in 1.0.0 (May 2020), use `cur_group_id()` instead. * The following were already soft-deprecated, and now warn once per session if used: * `cur_data()` and `cur_data_all()`. Deprecated in 1.1.0 (Jan 2023), use `pick()` instead. * The `...` argument of `across()`. Deprecated in 1.1.0 (Jan 2023), use an anonymous function instead. * Using `by = character()` to perform a cross join. Deprecated in 1.1.0 (Jan 2023), use `cross_join()` instead. ### Removed The following were already defunct, and have been removed: * `id()`. Deprecated in 0.5.0 (Jun 2016), use `vctrs::vec_group_id()` instead. If your package uses NSE and implicitly relied on the variable `id` being available, you now need to put `utils::globalVariables("id")` inside one of your package files to tell R that `id` is a column name. * `failwith()`. Deprecated in 0.7.0 (Jun 2017), use `purrr::possibly()` instead. * `select_vars()` and `select_vars_()`. Deprecated in 0.8.4 (Jan 2020), use `tidyselect::vars_select()` instead. * `rename_vars()` and `rename_vars_()`. Deprecated in 0.8.4 (Jan 2020), use `tidyselect::vars_rename()` instead. * `select_var()`. Deprecated in 0.8.4 (Jan 2020), use `tidyselect::vars_pull()` instead. * `current_vars()`. Deprecated in 0.8.4 (Jan 2020), use `tidyselect::peek_vars()` instead. * `bench_tbls()`, `compare_tbls()`, `compare_tbls2()`, `eval_tbls()`, and `eval_tbls2()`. Deprecated in 1.0.0 (May 2020). * `location()` and `changes()`. Deprecated in 1.0.0 (May 2020), use `lobstr::ref()` instead. ## Minor improvements and bug fixes * The base pipe is now used throughout the documentation (#7711). * The superseded `recode()` now has updated documentation showing how to migrate to `recode_values()` and `replace_values()`. * The `.groups` message emitted by `summarise()` is hopefully more clear now (#6986). * `storms` has been updated to include 2023 and 2024 data (#7111, @@tomalrussell). * `if_any()` and `if_all()` are now more consistent in all use cases (#7059, #7077, #7746, @@jrwinget). In particular: * When called with zero inputs, `if_any()` returns `FALSE` and `if_all()` returns `TRUE`. * When called with one input, both now return logical vectors rather than the original column. * The result of applying `.fns` now must be a logical vector. * `tally_n()` creates fully qualified funciton calls for duckplyr compatibility (#7046) * Empty `rowwise()` list-column elements now resolve to `logical()` rather than a random logical of length 1 (#7710). * `last_dplyr_warnings()` no longer prevents objects from being garbage collected (#7649). * `case_when()` now throws correctly indexed errors when `NULL`s are supplied in `...` (#7739). * `case_when()` now throws a better error if one of the conditions is an array (#6862, @@ilovemane). * `bind_rows()` now replaces empty (or `NA`) element names in a list with its numeric index while preserving existing names (#7719, @@Meghansaha). * New `slice_sample()` example showing how to use it to shuffle rows (#7707, @@Hzanib). * Updated `across()` examples to include an example using `everything()` (#7621, @@JBrandenburg02). * Clarified how `slice_min()` and `slice_max()` work in the introduction vignette (#7717, @@ccani007). * Fixed an edge case when coercing data frames to matrices (#7004). * Fixed an issue where duckplyr's ALTREP data frames were being materialized early due to internal usage of `ncol()` (#7049). * Progress towards making dplyr conformant with the public C API of R (#7741, #7797). * R >=4.1.0 is now required, in line with the [tidyverse standard](https://tidyverse.org/blog/2019/04/r-version-support/) of supporting the previous 5 minor releases of R (#7711). @ text @# $NetBSD: Makefile,v 1.12 2025/09/27 09:57:27 wiz Exp $ R_PKGNAME= dplyr R_PKGVER= 1.2.1 MAINTAINER= pkgsrc-users@@NetBSD.org COMMENT= Grammar of data manipulation PKGREVISION= 1 LICENSE= mit DEPENDS+= R-BH>=1.69.0.1:../../devel/R-BH DEPENDS+= R-R6>=2.4.0:../../devel/R-R6 DEPENDS+= R-assertthat>=0.2.0:../../devel/R-assertthat DEPENDS+= R-cli>=3.4.0:../../devel/R-cli #EPENDS+= R-ellipsis>=0.3.0:../../math/R-ellipsis DEPENDS+= R-generics-[0-9]*:../../math/R-generics DEPENDS+= R-glue>=1.3.2:../../devel/R-glue DEPENDS+= R-lifecycle>=1.0.3:../../devel/R-lifecycle DEPENDS+= R-magrittr>=1.5:../../devel/R-magrittr #EPENDS+= R-methods-[0-9]*:../../devel/R-methods DEPENDS+= R-pillar>=1.9.0:../../misc/R-pillar DEPENDS+= R-pkgconfig>=2.0.2:../../devel/R-pkgconfig DEPENDS+= R-rlang>=1.1.0:../../devel/R-rlang DEPENDS+= R-tibble>=3.2.0:../../math/R-tibble DEPENDS+= R-tidyselect>=1.2.0:../../devel/R-tidyselect DEPENDS+= R-vctrs>=0.6.4:../../math/R-vctrs DEPENDS+= R-generics>=0.0.2:../../math/R-generics DEPENDS+= R-generics>=0.0.2:../../math/R-generics # Packages suggested but not available: # 'Lahman', 'lobstr', 'nycflights13', 'RMySQL' TEST_DEPENDS+= R-bench-[0-9]*:../../benchmarks/R-bench TEST_DEPENDS+= R-broom-[0-9]*:../../math/R-broom TEST_DEPENDS+= R-callr-[0-9]*:../../devel/R-callr TEST_DEPENDS+= R-covr-[0-9]*:../../devel/R-covr TEST_DEPENDS+= R-dbplyr-[0-9]*:../../databases/R-dbplyr TEST_DEPENDS+= R-ggplot2-[0-9]*:../../graphics/R-ggplot2 TEST_DEPENDS+= R-knitr-[0-9]*:../../print/R-knitr #TEST_DEPENDS+= R-Lahman-[0-9]*: #TEST_DEPENDS+= R-lobstr-[0-9]*: TEST_DEPENDS+= R-microbenchmark-[0-9]*:../../benchmarks/R-microbenchmark #TEST_DEPENDS+= R-nycflights13-[0-9]*: TEST_DEPENDS+= R-rmarkdown-[0-9]*:../../textproc/R-rmarkdown #TEST_DEPENDS+= R-RMySQL-[0-9]*: TEST_DEPENDS+= R-RPostgreSQL-[0-9]*:../../math/R-RPostgreSQL TEST_DEPENDS+= R-RSQLite-[0-9]*:../../databases/R-RSQLite TEST_DEPENDS+= R-testthat-[0-9]*:../../devel/R-testthat TEST_DEPENDS+= R-tidyr-[0-9]*:../../math/R-tidyr TEST_DEPENDS+= R-withr-[0-9]*:../../devel/R-withr USE_LANGUAGES= c c++ .include "../../math/R/Makefile.extension" .include "../../devel/R-Rcpp/buildlink3.mk" .include "../../devel/R-plogr/buildlink3.mk" .include "../../devel/boost-headers/buildlink3.mk" .include "../../mk/bsd.pkg.mk" @ 1.12 log @*: recursive bump for boost 1.89 @ text @d1 1 a1 1 # $NetBSD: Makefile,v 1.11 2024/01/21 07:57:55 mef Exp $ d4 1 a4 1 R_PKGVER= 1.1.4 @ 1.11 log @(math/R-dplyr) Adjust as DEPENDS+= R-vctrs>=0.6.4 @ text @d1 1 a1 1 # $NetBSD: Makefile,v 1.10 2024/01/21 04:11:36 mef Exp $ d8 1 @ 1.10 log @(math/R-dplyr) Updated 1.1.2 to 1.1.4 # dplyr 1.1.4 * `join_by()` now allows its helper functions to be namespaced with `dplyr::`, like `join_by(dplyr::between(x, lower, upper))` (#6838). * `left_join()` and friends now return a specialized error message if they detect that your join would return more rows than dplyr can handle (#6912). * `slice_*()` now throw the correct error if you forget to name `n` while also prefixing the call with `dplyr::` (#6946). * `dplyr_reconstruct()`'s default method has been rewritten to avoid materializing duckplyr queries too early (#6947). * Updated the `storms` data to include 2022 data (#6937, @@steveharoz). * Updated the `starwars` data to use a new API, because the old one is defunct. There are very minor changes to the data itself (#6938, @@steveharoz). # dplyr 1.1.3 * `mutate_each()` and `summarise_each()` now throw correct deprecation messages (#6869). * `setequal()` now requires the input data frames to be compatible, similar to the other set methods like `setdiff()` or `intersect()` (#6786). @ text @d1 1 a1 1 # $NetBSD: Makefile,v 1.9 2023/06/02 12:58:09 mef Exp $ d25 1 a25 1 DEPENDS+= R-vctrs>=0.6.0:../../math/R-vctrs @ 1.9 log @(math/R-dplyr) Updated 1.1.0 to 1.1.2 # dplyr 1.1.2 * `count()` better documents that it has a `.drop` argument (#6820). * Fixed tests to maintain compatibility with the next version of waldo (#6823). * Joins better handle key columns will all `NA`s (#6804). # dplyr 1.1.1 * Mutating joins now warn about multiple matches much less often. At a high level, a warning was previously being thrown when a one-to-many or many-to-many relationship was detected between the keys of `x` and `y`, but is now only thrown for a many-to-many relationship, which is much rarer and much more dangerous than one-to-many because it can result in a Cartesian explosion in the number of rows returned from the join (#6731, #6717). We've accomplished this in two steps: * `multiple` now defaults to `"all"`, and the options of `"error"` and `"warning"` are now deprecated in favor of using `relationship` (see below). We are using an accelerated deprecation process for these two options because they've only been available for a few weeks, and `relationship` is a clearly superior alternative. * The mutating joins gain a new `relationship` argument, allowing you to optionally enforce one of the following relationship constraints between the keys of `x` and `y`: `"one-to-one"`, `"one-to-many"`, `"many-to-one"`, or `"many-to-many"`. For example, `"many-to-one"` enforces that each row in `x` can match at most 1 row in `y`. If a row in `x` matches >1 rows in `y`, an error is thrown. This option serves as the replacement for `multiple = "error"`. The default behavior of `relationship` doesn't assume that there is any relationship between `x` and `y`. However, for equality joins it will check for the presence of a many-to-many relationship, and will warn if it detects one. This change unfortunately does mean that if you have set `multiple = "all"` to avoid a warning and you happened to be doing a many-to-many style join, then you will need to replace `multiple = "all"` with `relationship = "many-to-many"` to silence the new warning, but we believe this should be rare since many-to-many relationships are fairly uncommon. * Fixed a major performance regression in `case_when()`. It is still a little slower than in dplyr 1.0.10, but we plan to improve this further in the future (#6674). * Fixed a performance regression related to `nth()`, `first()`, and `last()` (#6682). * Fixed an issue where expressions involving infix operators had an abnormally large amount of overhead (#6681). * `group_data()` on ungrouped data frames is faster (#6736). * `n()` is a little faster when there are many groups (#6727). * `pick()` now returns a 1 row, 0 column tibble when `...` evaluates to an empty selection. This makes it more compatible with [tidyverse recycling rules](https://vctrs.r-lib.org/reference/vector_recycling_rules.html) in some edge cases (#6685). * `if_else()` and `case_when()` again accept logical conditions that have attributes (#6678). * `arrange()` can once again sort the `numeric_version` type from base R (#6680). * `slice_sample()` now works when the input has a column named `replace`. `slice_min()` and `slice_max()` now work when the input has columns named `na_rm` or `with_ties` (#6725). * `nth()` now errors informatively if `n` is `NA` (#6682). * Joins now throw a more informative error when `y` doesn't have the same source as `x` (#6798). * All major dplyr verbs now throw an informative error message if the input data frame contains a column named `NA` or `""` (#6758). * Deprecation warnings thrown by `filter()` now mention the correct package where the problem originated from (#6679). * Fixed an issue where using `<-` within a grouped `mutate()` or `summarise()` could cross contaminate other groups (#6666). * The compatibility vignette has been replaced with a more general vignette on using dplyr in packages, `vignette("in-packages")` (#6702). * The developer documentation in `?dplyr_extending` has been refreshed and brought up to date with all changes made in 1.1.0 (#6695). * `rename_with()` now includes an example of using `paste0(recycle0 = TRUE)` to correctly handle empty selections (#6688). * R >=3.5.0 is now explicitly required. This is in line with the tidyverse policy of supporting the [5 most recent versions of R](https://www.tidyverse.org/blog/2019/04/r-version-support/). @ text @d1 1 a1 1 # $NetBSD: Makefile,v 1.8 2023/02/12 04:09:37 mef Exp $ d4 1 a4 1 R_PKGVER= 1.1.2 @ 1.8 log @(math/R-dplyr) Updated 1.0.1 to 1.1.0 # dplyr 1.1.0 ## New features * [`.by`/`by`](https://dplyr.tidyverse.org/dev/reference/dplyr_by.html) is an experimental alternative to `group_by()` that supports per-operation grouping for `mutate()`, `summarise()`, `filter()`, and the `slice()` family (#6528). Rather than: ``` starwars %>% group_by(species, homeworld) %>% summarise(mean_height = mean(height)) ``` You can now write: ``` starwars %>% summarise( mean_height = mean(height), .by = c(species, homeworld) ) ``` The most useful reason to do this is because `.by` only affects a single operation. In the example above, an ungrouped data frame went into the `summarise()` call, so an ungrouped data frame will come out; with `.by`, you never need to remember to `ungroup()` afterwards and you never need to use the `.groups` argument. Additionally, using `summarise()` with `.by` will never sort the results by the group key, unlike with `group_by()`. Instead, the results are returned using the existing ordering of the groups from the original data. We feel this is more predictable, better maintains any ordering you might have already applied with a previous call to `arrange()`, and provides a way to maintain the current ordering without having to resort to factors. This feature was inspired by [data.table](https://CRAN.R-project.org/package=data.table), where the equivalent syntax looks like: ``` starwars[, .(mean_height = mean(height)), by = .(species, homeworld)] ``` `with_groups()` is superseded in favor of `.by` (#6582). * `reframe()` is a new experimental verb that creates a new data frame by applying functions to columns of an existing data frame. It is very similar to `summarise()`, with two big differences: * `reframe()` can return an arbitrary number of rows per group, while `summarise()` reduces each group down to a single row. * `reframe()` always returns an ungrouped data frame, while `summarise()` might return a grouped or rowwise data frame, depending on the scenario. `reframe()` has been added in response to valid concern from the community that allowing `summarise()` to return any number of rows per group increases the chance for accidental bugs. We still feel that this is a powerful technique, and is a principled replacement for `do()`, so we have moved these features to `reframe()` (#6382). * `group_by()` now uses a new algorithm for computing groups. It is often faster than the previous approach (especially when there are many groups), and in most cases there should be no changes. The one exception is with character vectors, see the C locale news bullet below for more details (#4406, #6297). * `arrange()` now uses a faster algorithm for sorting character vectors, which is heavily inspired by data.table's `forder()`. See the C locale news bullet below for more details (#4962). * Joins have been completely overhauled to enable more flexible join operations and provide more tools for quality control. Many of these changes are inspired by data.table's join syntax (#5914, #5661, #5413, #2240). * A _join specification_ can now be created through `join_by()`. This allows you to specify both the left and right hand side of a join using unquoted column names, such as `join_by(sale_date == commercial_date)`. Join specifications can be supplied to any `*_join()` function as the `by` argument. * Join specifications allow for new types of joins: * Equality joins: The most common join, specified by `==`. For example, `join_by(sale_date == commercial_date)`. * Inequality joins: For joining on inequalities, i.e.`>=`, `>`, `<`, and `<=`. For example, use `join_by(sale_date >= commercial_date)` to find every commercial that aired before a particular sale. * Rolling joins: For "rolling" the closest match forward or backwards when there isn't an exact match, specified by using the rolling helper, `closest()`. For example, `join_by(closest(sale_date >= commercial_date))` to find only the most recent commercial that aired before a particular sale. * Overlap joins: For detecting overlaps between sets of columns, specified by using one of the overlap helpers: `between()`, `within()`, or `overlaps()`. For example, use `join_by(between(commercial_date, sale_date_lower, sale_date))` to find commercials that aired before a particular sale, as long as they occurred after some lower bound, such as 40 days before the sale was made. Note that you cannot use arbitrary expressions in the join conditions, like `join_by(sale_date - 40 >= commercial_date)`. Instead, use `mutate()` to create a new column containing the result of `sale_date - 40` and refer to that by name in `join_by()`. * `multiple` is a new argument for controlling what happens when a row in `x` matches multiple rows in `y`. For equality joins and rolling joins, where this is usually surprising, this defaults to signalling a `"warning"`, but still returns all of the matches. For inequality joins, where multiple matches are usually expected, this defaults to returning `"all"` of the matches. You can also return only the `"first"` or `"last"` match, `"any"` of the matches, or you can `"error"`. * `keep` now defaults to `NULL` rather than `FALSE`. `NULL` implies `keep = FALSE` for equality conditions, but `keep = TRUE` for inequality conditions, since you generally want to preserve both sides of an inequality join. * `unmatched` is a new argument for controlling what happens when a row would be dropped because it doesn't have a match. For backwards compatibility, the default is `"drop"`, but you can also choose to `"error"` if dropped rows would be surprising. * `across()` gains an experimental `.unpack` argument to optionally unpack (as in, `tidyr::unpack()`) data frames returned by functions in `.fns` (#6360). * `consecutive_id()` for creating groups based on contiguous runs of the same values, like `data.table::rleid()` (#1534). * `case_match()` is a "vectorised switch" variant of `case_when()` that matches on values rather than logical expressions. It is like a SQL "simple" `CASE WHEN` statement, whereas `case_when()` is like a SQL "searched" `CASE WHEN` statement (#6328). * `cross_join()` is a more explicit and slightly more correct replacement for using `by = character()` during a join (#6604). * `pick()` makes it easy to access a subset of columns from the current group. `pick()` is intended as a replacement for `across(.fns = NULL)`, `cur_data()`, and `cur_data_all()`. We feel that `pick()` is a much more evocative name when you are just trying to select a subset of columns from your data (#6204). * `symdiff()` computes the symmetric difference (#4811). ## Lifecycle changes ### Breaking changes * `arrange()` and `group_by()` now use the C locale, not the system locale, when ordering or grouping character vectors. This brings _substantial_ performance improvements, increases reproducibility across R sessions, makes dplyr more consistent with data.table, and we believe it should affect little existing code. If it does affect your code, you can use `options(dplyr.legacy_locale = TRUE)` to quickly revert to the previous behavior. However, in general, we instead recommend that you use the new `.locale` argument to precisely specify the desired locale. For a full explanation please read the associated [grouping](https://github.com/tidyverse/tidyups/blob/main/006-dplyr-group-by-ordering.md) and [ordering](https://github.com/tidyverse/tidyups/blob/main/003-dplyr-radix-ordering.md) tidyups. * `bench_tbls()`, `compare_tbls()`, `compare_tbls2()`, `eval_tbls()`, `eval_tbls2()`, `location()` and `changes()`, deprecated in 1.0.0, are now defunct (#6387). * `frame_data()`, `data_frame_()`, `lst_()` and `tbl_sum()` are no longer re-exported from tibble (#6276, #6277, #6278, #6284). * `select_vars()`, `rename_vars()`, `select_var()` and `current_vars()`, deprecated in 0.8.4, are now defunct (#6387). ### Newly deprecated * `across()`, `c_across()`, `if_any()`, and `if_all()` now require the `.cols` and `.fns` arguments. In general, we now recommend that you use `pick()` instead of an empty `across()` call or `across()` with no `.fns` (e.g. `across(c(x, y))`. (#6523). * Relying on the previous default of `.cols = everything()` is deprecated. We have skipped the soft-deprecation stage in this case, because indirect usage of `across()` and friends in this way is rare. * Relying on the previous default of `.fns = NULL` is not yet formally soft-deprecated, because there was no good alternative until now, but it is discouraged and will be soft-deprecated in the next minor release. * Passing `...` to `across()` is soft-deprecated because it's ambiguous when those arguments are evaluated. Now, instead of (e.g.) `across(a:b, mean, na.rm = TRUE)` you should write `across(a:b, ~ mean(.x, na.rm = TRUE))` (#6073). * `all_equal()` is deprecated. We've advised against it for some time, and we explicitly recommend you use `all.equal()`, manually reordering the rows and columns as needed (#6324). * `cur_data()` and `cur_data_all()` are soft-deprecated in favour of `pick()` (#6204). * Using `by = character()` to perform a cross join is now soft-deprecated in favor of `cross_join()` (#6604). * `filter()`ing with a 1-column matrix is deprecated (#6091). * `progress_estimate()` is deprecated for all uses (#6387). * Using `summarise()` to produce a 0 or >1 row "summary" is deprecated in favor of the new `reframe()`. See the NEWS bullet about `reframe()` for more details (#6382). * All functions deprecated in 1.0.0 (released April 2020) and earlier now warn every time you use them (#6387). This includes `combine()`, `src_local()`, `src_mysql()`, `src_postgres()`, `src_sqlite()`, `rename_vars_()`, `select_vars_()`, `summarise_each_()`, `mutate_each_()`, `as.tbl()`, `tbl_df()`, and a handful of older arguments. They are likely to be made defunct in the next major version (but not before mid 2024). * `slice()`ing with a 1-column matrix is deprecated. ### Newly superseded * `recode()` is superseded in favour of `case_match()` (#6433). * `recode_factor()` is superseded. We don't have a direct replacement for it yet, but we plan to add one to forcats. In the meantime you can often use `case_match(.ptype = factor(levels = ))` instead (#6433). * `transmute()` is superseded in favour of `mutate(.keep = "none")` (#6414). ### Newly stable * The `.keep`, `.before`, and `.after` arguments to `mutate()` have moved from experimental to stable. * The `rows_*()` family of functions have moved from experimental to stable. ## vctrs Many of dplyr's vector functions have been rewritten to make use of the vctrs package, bringing greater consistency and improved performance. * `between()` can now work with all vector types, not just numeric and date-time. Additionally, `left` and `right` can now also be vectors (with the same length as `x`), and `x`, `left`, and `right` are cast to the common type before the comparison is made (#6183, #6260, #6478). * `case_when()` (#5106): * Has a new `.default` argument that is intended to replace usage of `TRUE ~ default_value` as a more explicit and readable way to specify a default value. In the future, we will deprecate the unsafe recycling of the LHS inputs that allows `TRUE ~` to work, so we encourage you to switch to using `.default`. * No longer requires exact matching of the types of RHS values. For example, the following no longer requires you to use `NA_character_`. ``` x <- c("little", "unknown", "small", "missing", "large") case_when( x %in% c("little", "small") ~ "one", x %in% c("big", "large") ~ "two", x %in% c("missing", "unknown") ~ NA ) ``` * Supports a larger variety of RHS value types. For example, you can use a data frame to create multiple columns at once. * Has new `.ptype` and `.size` arguments which allow you to enforce a particular output type and size. * Has a better error when types or lengths were incompatible (#6261, #6206). * `coalesce()` (#6265): * Discards `NULL` inputs up front. * No longer iterates over the columns of data frame input. Instead, a row is now only coalesced if it is entirely missing, which is consistent with `vctrs::vec_detect_missing()` and greatly simplifies the implementation. * Has new `.ptype` and `.size` arguments which allow you to enforce a particular output type and size. * `first()`, `last()`, and `nth()` (#6331): * When used on a data frame, these functions now return a single row rather than a single column. This is more consistent with the vctrs principle that a data frame is generally treated as a vector of rows. * The `default` is no longer "guessed", and will always automatically be set to a missing value appropriate for the type of `x`. * Error if `n` is not an integer. `nth(x, n = 2)` is fine, but `nth(x, n = 2.5)` is now an error. Additionally, they have all gained an `na_rm` argument since they are summary functions (#6242, with contributions from @@tnederlof). * `if_else()` gains most of the same benefits as `case_when()`. In particular, `if_else()` now takes the common type of `true`, `false`, and `missing` to determine the output type, meaning that you can now reliably use `NA`, rather than `NA_character_` and friends (#6243). * `na_if()` (#6329) now casts `y` to the type of `x` before comparison, which makes it clearer that this function is type and size stable on `x`. In particular, this means that you can no longer do `na_if(, 0)`, which previously accidentally allowed you to replace any instance of `0` across every column of the tibble with `NA`. `na_if()` was never intended to work this way, and this is considered off-label usage. You can also now replace `NaN` values in `x` with `na_if(x, NaN)`. * `lag()` and `lead()` now cast `default` to the type of `x`, rather than taking the common type. This ensures that these functions are type stable on `x` (#6330). * `row_number()`, `min_rank()`, `dense_rank()`, `ntile()`, `cume_dist()`, and `percent_rank()` are faster and work for more types. You can now rank by multiple columns by supplying a data frame (#6428). * `with_order()` now checks that the size of `order_by` is the same size as `x`, and now works correctly when `order_by` is a data frame (#6334). ## Minor improvements and bug fixes * Fixed an issue with latest rlang that caused internal tools (such as `mask$eval_all_summarise()`) to be mentioned in error messages (#6308). * Warnings are enriched with contextualised information in `summarise()` and `filter()` just like they have been in `mutate()` and `arrange()`. * Joins now reference the correct column in `y` when a type error is thrown while joining on two columns with different names (#6465). * Joins on very wide tables are no longer bottlenecked by the application of `suffix` (#6642). * `*_join()` now error if you supply them with additional arguments that aren't used (#6228). * `across()` used without functions inside a rowwise-data frame no longer generates an invalid data frame (#6264). * Anonymous functions supplied with `function()` and `\()` are now inlined by `across()` if possible, which slightly improves performance and makes possible further optimisations in the future. * Functions supplied to `across()` are no longer masked by columns (#6545). For instance, `across(1:2, mean)` will now work as expected even if there is a column called `mean`. * `across()` will now error when supplied `...` without a `.fns` argument (#6638). * `arrange()` now correctly ignores `NULL` inputs (#6193). * `arrange()` now works correctly when `across()` calls are used as the 2nd (or more) ordering expression (#6495). * `arrange(df, mydesc::desc(x))` works correctly when mydesc re-exports `dplyr::desc()` (#6231). * `c_across()` now evaluates `all_of()` correctly and no longer allows you to accidentally select grouping variables (#6522). * `c_across()` now throws a more informative error if you try to rename during column selection (#6522). * dplyr no longer provides `count()` and `tally()` methods for `tbl_sql`. These methods have been accidentally overriding the `tbl_lazy` methods that dbplyr provides, which has resulted in issues with the grouping structure of the output (#6338, tidyverse/dbplyr#940). * `cur_group()` now works correctly with zero row grouped data frames (#6304). * `desc()` gives a useful error message if you give it a non-vector (#6028). * `distinct()` now retains attributes of bare data frames (#6318). * `distinct()` returns columns ordered the way you request, not the same as the input data (#6156). * Error messages in `group_by()`, `distinct()`, `tally()`, and `count()` are now more relevant (#6139). * `group_by_prepare()` loses the `caller_env` argument. It was rarely used and it is no longer needed (#6444). * `group_walk()` gains an explict `.keep` argument (#6530). * Warnings emitted inside `mutate()` and variants are now collected and stashed away. Run the new `last_dplyr_warnings()` function to see the warnings emitted within dplyr verbs during the last top-level command. This fixes performance issues when thousands of warnings are emitted with rowwise and grouped data frames (#6005, #6236). * `mutate()` behaves a little better with 0-row rowwise inputs (#6303). * A rowwise `mutate()` now automatically unlists list-columns containing length 1 vectors (#6302). * `nest_join()` has gained the `na_matches` argument that all other joins have. * `nest_join()` now preserves the type of `y` (#6295). * `n_distinct()` now errors if you don't give it any input (#6535). * `nth()`, `first()`, `last()`, and `with_order()` now sort character `order_by` vectors in the C locale. Using character vectors for `order_by` is rare, so we expect this to have little practical impact (#6451). * `ntile()` now requires `n` to be a single positive integer. * `relocate()` now works correctly with empty data frames and when `.before` or `.after` result in empty selections (#6167). * `relocate()` no longer drops attributes of bare data frames (#6341). * `relocate()` now retains the last name change when a single column is renamed multiple times while it is being moved. This better matches the behavior of `rename()` (#6209, with help from @@eutwt). * `rename()` now contains examples of using `all_of()` and `any_of()` to rename using a named character vector (#6644). * `rename_with()` now disallows renaming in the `.cols` tidy-selection (#6561). * `rename_with()` now checks that the result of `.fn` is the right type and size (#6561). * `rows_insert()` now checks that `y` contains the `by` columns (#6652). * `setequal()` ignores differences between freely coercible types (e.g. integer and double) (#6114) and ignores duplicated rows (#6057). * `slice()` helpers again produce output equivalent to `slice(.data, 0)` when the `n` or `prop` argument is 0, fixing a bug introduced in the previous version (@@eutwt, #6184). * `slice()` with no inputs now returns 0 rows. This is mostly for theoretical consistency (#6573). * `slice()` now errors if any expressions in `...` are named. This helps avoid accidentally misspelling an optional argument, such as `.by` (#6554). * `slice_*()` now requires `n` to be an integer. * `slice_*()` generics now perform argument validation. This should make methods more consistent and simpler to implement (#6361). * `slice_min()` and `slice_max()` can `order_by` multiple variables if you supply them as a data.frame or tibble (#6176). * `slice_min()` and `slice_max()` now consistently include missing values in the result if necessary (i.e. there aren't enough non-missing values to reach the `n` or `prop` you have selected). If you don't want missing values to be included at all, set `na_rm = TRUE` (#6177). * `slice_sample()` now accepts negative `n` and `prop` values (#6402). * `slice_sample()` returns a data frame or group with the same number of rows as the input when `replace = FALSE` and `n` is larger than the number of rows or `prop` is larger than 1. This reverts a change made in 1.0.8, returning to the behavior of 1.0.7 (#6185) * `slice_sample()` now gives a more informative error when `replace = FALSE` and the number of rows requested in the sample exceeds the number of rows in the data (#6271). * `storms` has been updated to include 2021 data and some missing storms that were omitted due to an error (@@steveharoz, #6320). * `summarise()` now correctly recycles named 0-column data frames (#6509). * `union_all()`, like `union()`, now requires that data frames be compatible: i.e. they have the same columns, and the columns have compatible types. * `where()` is re-exported from tidyselect (#6597). @ text @d1 1 a1 1 # $NetBSD: Makefile,v 1.7 2022/12/18 05:38:37 mef Exp $ d4 1 a4 1 R_PKGVER= 1.1.0 d13 3 d17 1 a17 1 DEPENDS+= R-lifecycle>=0.2.0:../../devel/R-lifecycle d19 2 d22 5 a26 3 DEPENDS+= R-rlang>=0.4.6:../../devel/R-rlang DEPENDS+= R-tidyselect>=1.1.0:../../devel/R-tidyselect DEPENDS+= R-ellipsis>=0.3.0:../../math/R-ellipsis a27 2 DEPENDS+= R-tibble>=2.1.3:../../math/R-tibble DEPENDS+= R-vctrs>=0.4.1:../../math/R-vctrs @ 1.7 log @ (math/R-dplyr) Updated 1.0.9 to 1.0.10 # dplyr 1.0.10 Hot patch release to resolve R CMD check failures. @ text @d1 1 a1 1 # $NetBSD: Makefile,v 1.6 2022/05/22 12:24:04 mef Exp $ d4 1 a4 1 R_PKGVER= 1.0.10 @ 1.6 log @(math/R-dplyr) Updated 1.0.7 to 1.0.9 # dplyr 1.0.9 * New `rows_append()` which works like `rows_insert()` but ignores keys and allows you to insert arbitrary rows with a guarantee that the type of `x` won't change (#6249, thanks to @@krlmlr for the implementation and @@mgirlich for the idea). * The `rows_*()` functions no longer require that the key values in `x` uniquely identify each row. Additionally, `rows_insert()` and `rows_delete()` no longer require that the key values in `y` uniquely identify each row. Relaxing this restriction should make these functions more practically useful for data frames, and alternative backends can enforce this in other ways as needed (i.e. through primary keys) (#5553). * `rows_insert()` gained a new `conflict` argument allowing you greater control over rows in `y` with keys that conflict with keys in `x`. A conflict arises if a key in `y` already exists in `x`. By default, a conflict results in an error, but you can now also `"ignore"` these `y` rows. This is very similar to the `ON CONFLICT DO NOTHING` command from SQL (#5588, with helpful additions from @@mgirlich and @@krlmlr). * `rows_update()`, `rows_patch()`, and `rows_delete()` gained a new `unmatched` argument allowing you greater control over rows in `y` with keys that are unmatched by the keys in `x`. By default, an unmatched key results in an error, but you can now also `"ignore"` these `y` rows (#5984, #5699). * `rows_delete()` no longer requires that the columns of `y` be a strict subset of `x`. Only the columns specified through `by` will be utilized from `y`, all others will be dropped with a message. * The `rows_*()` functions now always retain the column types of `x`. This behavior was documented, but previously wasn't being applied correctly (#6240). * The `rows_*()` functions now fail elegantly if `y` is a zero column data frame and `by` isn't specified (#6179). # dplyr 1.0.8 * Better display of error messages thanks to rlang 1.0.0. * `mutate(.keep = "none")` is no longer identical to `transmute()`. `transmute()` has not been changed, and completely ignores the column ordering of the existing data, instead relying on the ordering of expressions supplied through `...`. `mutate(.keep = "none")` has been changed to ensure that pre-existing columns are never moved, which aligns more closely with the other `.keep` options (#6086). * `filter()` forbids matrix results (#5973) and warns about data frame results, especially data frames created from `across()` with a hint to use `if_any()` or `if_all()`. * `slice()` helpers (`slice_head()`, `slice_tail()`, `slice_min()`, `slice_max()`) now accept negative values for `n` and `prop` (#5961). * `slice()` now indicates which group produces an error (#5931). * `cur_data()` and `cur_data_all()` don't simplify list columns in rowwise data frames (#5901). * dplyr now uses `rlang::check_installed()` to prompt you whether to install required packages that are missing. * `storms` data updated to 2020 (@@steveharoz, #5899). * `coalesce()` accepts 1-D arrays (#5557). * The deprecated `trunc_mat()` is no longer reexported from dplyr (#6141). @ text @d1 1 a1 1 # $NetBSD: Makefile,v 1.5 2021/09/11 15:31:54 mef Exp $ d4 1 a4 1 R_PKGVER= 1.0.9 d25 1 a25 1 # 'bench', 'Lahman', 'lobstr', 'nycflights13', 'RMySQL' d27 1 a27 3 #TEST_DEPENDS+= R-bench-[0-9]*: @ 1.5 log @(math/R-dplyr) Updated 1.0.6 to 1.0.7 # dplyr 1.0.7 * `across()` uses the formula environment when inlining them (#5886). * `summarise.rowwise_df()` is quiet when the result is ungrouped (#5875). * `c_across()` and `across()` key deparsing not confused by long calls (#5883). * `across()` handles named selections (#5207). @ text @d1 1 a1 1 # $NetBSD: Makefile,v 1.4 2021/06/12 22:36:14 mef Exp $ d4 1 a4 1 R_PKGVER= 1.0.7 d22 1 a22 1 DEPENDS+= R-vctrs>=0.3.0:../../math/R-vctrs d25 1 a25 2 # 'bench', 'broom', 'dbplyr', 'Lahman', 'lobstr', 'nycflights13', # 'RMySQL', 'RPostgreSQL' d27 4 a30 1 TEST_DEPENDS+= R-RSQLite-[0-9]*:../../databases/R-RSQLite d33 2 a34 1 TEST_DEPENDS+= R-dplyr-[0-9]*:../../math/R-dplyr d36 2 d39 1 d41 3 @ 1.4 log @(math/R-dplyr) Updated 1.0.0 to 1.0.6 # dplyr 1.0.6 * `add_count()` is now generic (#5837). * `if_any()` and `if_all()` abort when a predicate is mistakingly used as `.cols=` (#5732). * Multiple calls to `if_any()` and/or `if_all()` in the same expression are now properly disambiguated (#5782). * `filter()` now inlines `if_any()` and `if_all()` expressions. This greatly improves performance with grouped data frames. * Fixed behaviour of `...` in top-level `across()` calls (#5813, #5832). * `across()` now inlines lambda-formulas. This is slightly more performant and will allow more optimisations in the future. * Fixed issue in `bind_rows()` causing lists to be incorrectly transformed as data frames (#5417, #5749). * `select()` no longer creates duplicate variables when renaming a variable to the same name as a grouping variable (#5841). * `dplyr_col_select()` keeps attributes for bare data frames (#5294, #5831). * Fixed quosure handling in `dplyr::group_by()` that caused issues with extra arguments (tidyverse/lubridate#959). * Removed the `name` argument from the `compute()` generic (@@ianmcook, #5783). * row-wise data frames of 0 rows and list columns are supported again (#5804). # dplyr 1.0.5 * Fixed edge case of `slice_sample()` when `weight_by=` is used and there 0 rows (#5729). * `across()` can again use columns in functions defined inline (#5734). * Using testthat 3rd edition. * Fixed bugs introduced in `across()` in previous version (#5765). * `group_by()` keeps attributes unrelated to the grouping (#5760). * The `.cols=` argument of `if_any()` and `if_all()` defaults to `everything()`. # dplyr 1.0.4 * Improved performance for `across()`. This makes `summarise(across())` and `mutate(across())` perform as well as the superseded colwise equivalents (#5697). * New functions `if_any()` and `if_all()` (#4770, #5713). * `summarise()` silently ignores NULL results (#5708). * Fixed a performance regression in `mutate()` when warnings occur once per group (#5675). We no longer instrument warnings with debugging information when `mutate()` is called within `suppressWarnings()`. # dplyr 1.0.3 * `summarise()` no longer informs when the result is ungrouped (#5633). * `group_by(.drop = FALSE)` preserves ordered factors (@@brianrice2, #5545). * `count()` and `tally()` are now generic. * Removed default fallbacks to lazyeval methods; this will yield better error messages when you call a dplyr function with the wrong input, and is part of our long term plan to remove the deprecated lazyeval interface. * `inner_join()` gains a `keep` parameter for consistency with the other mutating joins (@@patrickbarks, #5581). * Improved performance with many columns, with a dynamic data mask using active bindings and lazy chops (#5017). * `mutate()` and friends preserves row names in data frames once more (#5418). * `group_by()` uses the ungrouped data for the implicit mutate step (#5598). You might have to define an `ungroup()` method for custom classes. For example, see https://github.com/hadley/cubelyr/pull/3. * `relocate()` can rename columns it relocates (#5569). * `distinct()` and `group_by()` have better error messages when the mutate step fails (#5060). * Clarify that `between()` is not vectorised (#5493). * Fixed `across()` issue where data frame columns would could not be referred to with `all_of()` in the nested case (`mutate()` within `mutate()`) (#5498). * `across()` handles data frames with 0 columns (#5523). * `mutate()` always keeps grouping variables, unconditional to `.keep=` (#5582). * dplyr now depends on R 3.3.0 # dplyr 1.0.2 * Fixed `across()` issue where data frame columns would mask objects referred to from `all_of()` (#5460). * `bind_cols()` gains a `.name_repair` argument, passed to `vctrs::vec_cbind()` (#5451) * `summarise(.groups = "rowwise")` makes a rowwise data frame even if the input data is not grouped (#5422). # dplyr 1.0.1 * New function `cur_data_all()` similar to `cur_data()` but includes the grouping variables (#5342). * `count()` and `tally()` no longer automatically weights by column `n` if present (#5298). dplyr 1.0.0 introduced this behaviour because of Hadley's faulty memory. Historically `tally()` automatically weighted and `count()` did not, but this behaviour was accidentally changed in 0.8.2 (#4408) so that neither automatically weighted by `n`. Since 0.8.2 is almost a year old, and the automatically weighting behaviour was a little confusing anyway, we've removed it from both `count()` and `tally()`. Use of `wt = n()` is now deprecated; now just omit the `wt` argument. * `coalesce()` now supports data frames correctly (#5326). * `cummean()` no longer has off-by-one indexing problem (@@cropgen, #5287). * The call stack is preserved on error. This makes it possible to `recover()` into problematic code called from dplyr verbs (#5308). @ text @d1 1 a1 1 # $NetBSD: Makefile,v 1.3 2020/07/31 20:44:49 brook Exp $ d4 1 a4 1 R_PKGVER= 1.0.6 d25 3 a27 2 # 'bench', 'broom', 'dbplyr', 'Lahman', 'lobstr', 'microbenchmark', # 'nycflights13', 'RMySQL', 'RPostgreSQL', 'RSQLite', 'tidyr' d29 2 d32 1 d34 2 d37 1 @ 1.3 log @R-dplyr: updated to 1.0.0. @ text @d1 1 a1 1 # $NetBSD: Makefile,v 1.2 2019/09/25 17:26:38 brook Exp $ d4 1 a4 1 R_PKGVER= 1.0.0 d24 8 @ 1.2 log @Add missing dependencies on devel/R-BH and devel/R-R6. @ text @d1 1 a1 1 # $NetBSD: Makefile,v 1.1 2019/08/09 16:23:47 brook Exp $ d4 1 a4 2 R_PKGVER= 0.8.3 CATEGORIES= math d13 2 a14 1 DEPENDS+= R-glue>=1.3.0:../../devel/R-glue d17 6 a22 3 DEPENDS+= R-rlang>=0.4.0:../../devel/R-rlang DEPENDS+= R-tidyselect>=0.2.5:../../devel/R-tidyselect DEPENDS+= R-tibble>=2.0.0:../../math/R-tibble @ 1.1 log @R-dplyr: initial commit A fast, consistent tool for working with data frame like objects, both in memory and out of memory. @ text @d1 1 a1 1 # $NetBSD$ d11 2 @