README: add section on common sequential iterator packages and functions

Author: HenrikBengtsson

OVERVIEW.md

@@ -105,12 +105,51 @@ handlers("txtprogressbar", "beepr")
 
 ## Support for progressr elsewhere
 
-### The future framework
+Note that progression updates by **progressr** is designed to work out of the box for any _sequential_ iterator framework in R.  Here is an set of examples for the most common ones:
+
+```r
+library(progressr)
+
+xs <- 1:5
+y_truth <- lapply(xs, slow_sqrt)
+
+with_progress({
+  p <- progressor(along = xs)
+  y <- lapply(xs, function(x) {
+    p(sprintf("x=%g", x))
+    Sys.sleep(0.1)
+    sqrt(x)
+  })
+})
+
+library(foreach)
+with_progress({
+  p <- progressor(along = xs)
+  y <- foreach(x = xs) %do% {
+    p(sprintf("x=%g", x))
+    Sys.sleep(0.1)
+    sqrt(x)
+  }
+})
+
+library(purrr)
+with_progress({
+  p <- progressor(along = xs)
+  y <- map(xs, function(x) {
+    p(sprintf("x=%g", x))
+    Sys.sleep(0.1)
+    sqrt(x)
+  })
+})
+```
 
-The **[future]** framework has built-in support for the kind of progression updates produced by the **progressr** package.  This means that you can use it with for instance **[future.apply]**, **[furrr]**, and **[foreach]** with **[doFuture]**.
 
+### Parallel processing and progress updates
 
-#### future_lapply()
+The **[future]** framework, which provides a unified API for parallel and distributed processing in R, has built-in support for the kind of progression updates produced by the **progressr** package.  This means that you can use it with for instance **[future.apply]**, **[furrr]**, and **[foreach]** with **[doFuture]**.
+
+
+#### future_lapply() - parallel lapply()
 
 Here is an example that uses `future_lapply()` of the **[future.apply]** package to parallelize on the local machine while at the same time signaling progression updates:
 
@@ -161,6 +200,29 @@ with_progress({
 ```
 
 
+#### future_map() - parallel purrr::map()
+
+```r
+library(furrr)
+plan(multisession)
+
+library(progressr)
+handlers("progress", "beepr")
+
+xs <- 1:5
+
+with_progress({
+  p <- progressor(along = xs)
+  y <- future_map(xs, function(x) {
+    p(sprintf("x=%g", x))
+    Sys.sleep(6.0-x)
+    sqrt(x)
+  })
+})
+## [=================>-----------------------------]  40% x=2
+```
+
+
 ### The plyr package
 
 The functions in the [**plyr**](https://cran.r-project.org/package=plyr) package take argument `.progress`, which can be used to produce progress updates.  To have them generate **progressr** 'progression' updates, use `.progress = "progressr"`. For example,

README.md

@@ -107,12 +107,51 @@ handlers("txtprogressbar", "beepr")
 
 ## Support for progressr elsewhere
 
-### The future framework
+Note that progression updates by **progressr** is designed to work out of the box for any _sequential_ iterator framework in R.  Here is an set of examples for the most common ones:
+
+```r
+library(progressr)
+
+xs <- 1:5
+y_truth <- lapply(xs, slow_sqrt)
+
+with_progress({
+  p <- progressor(along = xs)
+  y <- lapply(xs, function(x) {
+    p(sprintf("x=%g", x))
+    Sys.sleep(0.1)
+    sqrt(x)
+  })
+})
+
+library(foreach)
+with_progress({
+  p <- progressor(along = xs)
+  y <- foreach(x = xs) %do% {
+    p(sprintf("x=%g", x))
+    Sys.sleep(0.1)
+    sqrt(x)
+  }
+})
+
+library(purrr)
+with_progress({
+  p <- progressor(along = xs)
+  y <- map(xs, function(x) {
+    p(sprintf("x=%g", x))
+    Sys.sleep(0.1)
+    sqrt(x)
+  })
+})
+```
 
-The **[future]** framework has built-in support for the kind of progression updates produced by the **progressr** package.  This means that you can use it with for instance **[future.apply]**, **[furrr]**, and **[foreach]** with **[doFuture]**.
 
+### Parallel processing and progress updates
 
-#### future_lapply()
+The **[future]** framework, which provides a unified API for parallel and distributed processing in R, has built-in support for the kind of progression updates produced by the **progressr** package.  This means that you can use it with for instance **[future.apply]**, **[furrr]**, and **[foreach]** with **[doFuture]**.
+
+
+#### future_lapply() - parallel lapply()
 
 Here is an example that uses `future_lapply()` of the **[future.apply]** package to parallelize on the local machine while at the same time signaling progression updates:
 
@@ -163,6 +202,29 @@ with_progress({
 ```
 
 
+#### future_map() - parallel purrr::map()
+
+```r
+library(furrr)
+plan(multisession)
+
+library(progressr)
+handlers("progress", "beepr")
+
+xs <- 1:5
+
+with_progress({
+  p <- progressor(along = xs)
+  y <- future_map(xs, function(x) {
+    p(sprintf("x=%g", x))
+    Sys.sleep(6.0-x)
+    sqrt(x)
+  })
+})
+## [=================>-----------------------------]  40% x=2
+```
+
+
 ### The plyr package
 
 The functions in the [**plyr**](https://cran.r-project.org/package=plyr) package take argument `.progress`, which can be used to produce progress updates.  To have them generate **progressr** 'progression' updates, use `.progress = "progressr"`. For example,