Log Message:
(devel/R-purrr) Update 0.3.5 to 1.0.0

# purrr 1.0.0

## Breaking changes

### Core purpose refinements

* `cross()` and all its variants have been deprecated in favour of
  `tidyr::expand_grid()`. These functions were slow and buggy and we
  no longer think they are the right approach to solving this problem.
  See #768 for more information.

* `update_list()` (#858) and `rerun()` (#877), and the use of tidyselect
  with `map_at()` and friends (#874) have been deprecated. These functions
  use some form of non-standard evaluation which we now believe is a poor
  fit for purrr.

* The `lift_*` family of functions has been deprecated. We no longer believe
  these to be a good fit for purrr because they rely on a style of function
  manipulation that is very uncommon in R code (#871).

* `prepend()`, `rdunif()`, `rbernoulli()`, `when()`, and `list_along()` have
  all been deprecated (#925). It's now clear that they don't align with the
  core purpose of purrr.

* `splice()` is deprecated because we no longer believe that automatic
  splicing makes for good UI. Instead use `list2()` + `!!!` or
  `list_flatten()` (#869).

### Mapping

* Use of map functions with expressions, calls, and pairlists has been
  deprecated (#961).

* All map `_raw()` variants have been deprecated because they are of limited
  use and you can now use `map_vec()` instead (#903).

* In `map_chr()`, automatic conversion from logical, integer, and double to
  character is now deprecated. Use an explicit `as.character()` if needed
  (#904).

### Deprecation next steps

* `as_function()` and the `...f` argument to `partial()` are no longer
  supported. They have been defunct for quite some time.

* Soft deprecated functions: `%@%`, `reduce_right()`, `reduce2_right()`,
  `accumulate_right()` are now fully deprecated. Similarly, the
  `.lazy`, `.env`, and `.first` arguments to `partial()`,
  and the `.right` argument to `detect()` and `detect_index()`
  are fully deprecated. Removing elements with `NULL` in `list_modify()` and
  `list_merge()` is now fully deprecated.

* `is_numeric()` and `is_scalar_numeric()` have been removed. They have
  been deprecated since purrr 0.2.3 (Sep 2017).

* `invoke_*()` is now deprecated. It was superseded in 0.3.0 (Jan 2019) and
  3.5 years later, we have decided to deprecate it as part of the API
  refinement in the 1.0.0 release.

* `map_call()` has been removed. It was made defunct in 0.3.0 (Jan 2019).

## New features

* `*_at()` can now take a function (or formula) that's passed the vector of
  element names and returns the elements to select.

* New `map_vec()`, `map2_vec()`, and `pmap_vec()` work on all types of vectors,
  extending `map_lgl()`, `map_int()`, and friends so that you can easily work
  with dates, factors, date-times and more (#435).

* New `keep_at()` and `discard_at()` that work like `keep()` and `discard()`
  but operation on element names rather than element contents (#817).

* Some mapping functions have now a `.progress` argument to create a
  progress bar. See `?progress_bars` (#149).

* purrr is now licensed as MIT (#805).

* `modify()`, `modify_if()`, `modify_at()`, and `modify2()` are no longer
  generics. We have discovered a simple implementation that no longer requires
  genericity and methods were only provided by a very small number of packages
  (#894).

* purrr now uses the base pipe (`|>`) and anonymous function short hand (`\(x)`),
  in all examples. This means that examples will no longer work in R 4.0 and
  earlier so in those versions of R, the examples are automatically converted
  to a regular section with a note that they might not work (#936).

* When map functions fail, they now report the element they failed at (#945).

* New `modify_tree()` for recursively modifying nested data structures (#720).

### Flattening and simplification

* New `list_c()`, `list_rbind()`, and `list_cbind()` make it easy to
  `c()`, `rbind()`, or `cbind()` all of the elements in a list.

* New `list_simplify()` reduces a list of length-1 vectors to a simpler atomic
  or S3 vector (#900).

* New `list_transpose()` which automatically simplifies if possible (#875).

* `accumulate()` and `accumulate2()` now both simplify the output if possible
  using vctrs. New arguments `simplify` and `ptype` allow you to control the
  details of simplification (#774, #809).

* `flatten()` and friends are superseded in favour of `list_flatten()`,
  `list_c()`, `list_cbind()`, and `list_rbind()`.

* `*_dfc()` and `*_dfr()` have been superseded in favour of using the
  appropriate map function along with `list_rbind()` or `list_cbind()` (#912).

* `simplify()`, `simplify_all()`, and `as_vector()` have been superseded in
  favour of `list_simplify()`. It provides a more consistent definition of
  simplification (#900).

* `transpose()` has been superseded in favour of `list_transpose()` (#875).
  It has built-in simplification.

### Tidyverse consistency

* `_lgl()`, `_int()`, `_int()`, and `_dbl()` now use the same (strict) coercion
  methods as vctrs (#904). This means that:

    * `map_chr(TRUE, identity)`, `map_chr(0L, identity)`, and
      `map_chr(1L, identity)` are deprecated because we now believe that
      converting a logical/integer/double to a character vector should require
      an explicit coercion.

    * `map_int(1.5, identity)` now fails because we believe that silently
      truncating doubles to integers is dangerous. But note that
      `map_int(1, identity)` still works since no numeric precision is lost.

    * `map_int(c(TRUE, FALSE), identity)`, `map_dbl(c(TRUE, FALSE), identity)`,
      `map_lgl(c(1L, 0L), identity)` and `map_lgl(c(1, 0), identity)` now
      succeed because 1/TRUE and 0/FALSE should be interchangeable.

* `map2()`, `modify2()`, and `pmap()` now use tidyverse recycling rules where
  vectors of length 1 are recycled to any size but all others must have
  the same length (#878).

* `map2()` and `pmap()` now recycle names of their first input if
  needed (#783).

* `modify()`, `modify_if()`, and `modify_at()` have been reimplemented using
  vctrs principles. This shouldn't have an user facing impact, but it does
  make the implementation much simpler.

### Plucking

* `vec_depth()` is now `pluck_depth()` and works with more types of input
  (#818).

* `pluck()` now requires indices to be length 1 (#813). It also now reports
  the correct type if you supply an unexpected index.

* `pluck()` now accepts negative integers, indexing from the right (#603).

* `pluck()` and `chuck()` now fail if you provide named inputs to ... (#788).

* `pluck()` no longer replaces 0-length vectors with `default`; it now
  only applies absent and `NULL` components (#480).

* `pluck<-`/`assign_in()` can now modify non-existing locations (#704).

### Setting with NULL

* `pluck<-`/`assign_in()` now sets elements to `NULL` rather than removing them
  (#636). Now use the explicit `zap()` if you want to remove elements.

* `modify()`, `modify2()`, and `modify_if()` now correctly handle `NULL`s
  in replacement values (#655, #746, #753).

* `list_modify()`'s interface has been standardised. Modifying with `NULL`
  now always creates a `NULL` in the output (#810)

### `list_` functions`

* New `list_assign()` which is similar to `list_modify()` but doesn't work
  recursively (#822).

* `list_modify()` no longer recurses into data frames (and other objects built
  on top of lists that are fundamentally non-list like) (#810). You can
  revert to the previous behaviour by setting `.is_node = is.list`.

## Minor improvements and bug fixes

* `capture_output()` correctly uses `conditionMessage()` instead of directly
  interrogating the `message` field (#1010).

* `modify()` no longer works with calls or pairlists.

* `modify_depth()` is no longer a generic. This makes it more consistent
  with `map_depth()`.

* `map_depth()` and `modify_depth()` have a new `is_node` argument that
  allows you to control what counts as a level. The default uses
  `vec_is_list()` to avoid recursing into rich S3 objects like linear models
  or data.frames (#958, #920).

* `map_depth()` and `modify_depth()` now correctly recurse at depth 1.

* `as_mapper()` is now around twice as fast when used with character,
  integer, or list (#820).

* `possibly()` now defaults `otherwise` to NULL.

* `modify_if(.else)` is now actually evaluated for atomic vectors (@mgirlich,
  #701).

* `lmap_if()` correctly handles `.else` functions (#847).

* `every()` now correctly propagates missing values using the same
  rules as `&&` (#751). Internally, it has become a wrapper around
  `&&`. This makes it consistent with `&&` and also with `some()`
  which has always been a wrapper around `||` with the same
  propagation rules.

* `every()` and `some()` now properly check the return value of their
  predicate function. It must now return a `TRUE`, `FALSE`, or `NA`.

* Greatly improved performance of functions created with `partial()` (#715).
  Their invocation is now as fast as for functions creating manually.

* `partial()` no longer inlines the function in the call stack. This
  fixes issues when `partial()` is used with `lm()` for instance (#707).