45 | 
12 |
13 | [](https://travis-ci.org/mkearney/dapr)
14 | [](https://cran.r-project.org/package=dapr)
15 | [](https://codecov.io/gh/mkearney/dapr?branch=master)
16 | [](https://doi.org/10.5281/zenodo.2528504)
17 | 
18 | 
19 | [](https://www.tidyverse.org/lifecycle/#experimental)
20 |
21 | Dependency-free purrr-like apply/map/iterate functions
22 |
23 | ## Installation
24 |
25 | Install the development version from Github with:
26 |
27 | ``` r
28 | ## install remotes pkg if not already
29 | if (!requireNamespace("remotes", quietly = TRUE)) {
30 | install.packages("remotes")
31 | }
32 |
33 | ## install from github
34 | remotes::install_github("mkearney/dapr")
35 | ```
36 |
37 | ## {dapr} vs. {base} & {purrr}?
38 | **{dapr}** provides the ease and consistency of [**{purrr}**](https://purrr.tidyverse.org),
39 | (see also: simple benchmark results plot below) including use of `~` and `.x`,
40 | without all the dependencies. In other words, use **{dapr}** when you want a
41 | purrr-like experience but you need a lightweight solution.
42 |
43 |
44 |
45 |
vap for **vectors**
52 | + lap for **lists**
53 | + dap for **data frames**
54 |
55 | Common inputs:
56 |
57 | + `.data` Input object–numeric, character, list, data frame, etc.–over which elements will be iterated. If matrix or data frame, each column will be treated as the elements which are to be iterated over.
58 | + `.f` Function to apply to each element of input object. This can be written as a single function name e.g., `mean`, a formula-like function call where `.x` is assumed to be the iterated over element of input data e.g., `~ mean(.x)`, or an in-line function definition e.g., `function(x) mean(x)`.
59 |
60 | ### Vectors
61 |
62 | Functions that apply expressions to input data objects and return atomic vectors
63 | e.g., numeric (double), character, logical.
64 |
65 | + **`vap_dbl()`** Iterate and return **numeric** vector.
66 | + **`vap_int()`** Iterate and return **integer** vector.
67 | + **`vap_lgl()`** Iterate and return **logical** vector.
68 | + **`vap_chr()`** Iterate and return **character** vector.
69 |
70 | ```{r}
71 | ## create data
72 | set.seed(2018)
73 | d <- replicate(5, rnorm(10), simplify = FALSE)
74 | e <- replicate(5, sample(letters, 10), simplify = FALSE)
75 |
76 | ## numeric
77 | vap_dbl(d, ~ mean(.x))
78 |
79 | ## integer
80 | vap_int(d, length)
81 |
82 | ## logical
83 | vap_lgl(d, ~ max(.x) > 3)
84 |
85 | ## character
86 | vap_chr(e, paste, collapse = "")
87 | ```
88 |
89 | ### Lists
90 |
91 | Function(s) that apply expressions to input data objects and return lists.
92 |
93 | + **`lap()`** Iterate and return a **list** vector.
94 |
95 | ```{r}
96 | ## list of strings
97 | lap(e[1:2], ~ paste0(.x, "."))
98 | ```
99 |
100 | + **`ilap()`** Iterate over sequence length `.i` (instead of `.x`) and return a **list** vector.
101 |
102 | ```{r}
103 | ## list of strings
104 | ilap(1:4, ~ paste0(letters[.i], rev(LETTERS)[.i]))
105 | ```
106 |
107 | ### Data frames
108 |
109 | Functions that apply expressions to input data objects and return data frames.
110 |
111 | + **`dap*()`** Iterate and return a **data frame**
112 | - **`dapc()`** Iterate over **columns**
113 | - **`dapr()`** Iterate over **rows**
114 | + **`dap*_if()`** Conditionally iterate
115 | - **`dapc_if()`** Conditionally iterate over **columns**
116 | - **`dapr_if()`** Conditionally iterate over **rows**
117 |
118 | ```{r}
119 | ## some data
120 | d <- data.frame(
121 | a = letters[1:3],
122 | b = rnorm(3),
123 | c = rnorm(3),
124 | stringsAsFactors = FALSE
125 | )
126 |
127 | ## column explicit (same as dap)
128 | dapc(d[-1], ~ round(.x, 2))
129 |
130 | ## rows
131 | dapr(d[-1], round, 3)
132 |
133 | ## conditional COLUMNS
134 | dapc_if(d, is.numeric, ~ round(.x, 4))
135 |
136 | ## conditional ROWS
137 | dapr_if(d[-1], ~ sum(.x) >= -.7, ~ round(.x, 0))
138 | ```
139 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | # dapr
5 |
6 | [](https://travis-ci.org/mkearney/dapr)
8 | [](https://cran.r-project.org/package=dapr)
10 | [](https://codecov.io/gh/mkearney/dapr?branch=master)
12 | [](https://doi.org/10.5281/zenodo.2528504)
13 | 
14 | 
15 | [](https://www.tidyverse.org/lifecycle/#experimental)
16 |
17 | Dependency-free purrr-like apply/map/iterate functions
18 |
19 | ## Installation
20 |
21 | Install the development version from Github with:
22 |
23 | ``` r
24 | ## install remotes pkg if not already
25 | if (!requireNamespace("remotes", quietly = TRUE)) {
26 | install.packages("remotes")
27 | }
28 |
29 | ## install from github
30 | remotes::install_github("mkearney/dapr")
31 | ```
32 |
33 | ## {dapr} vs. {base} & {purrr}?
34 |
35 | **{dapr}** provides the ease and consistency of
36 | [**{purrr}**](https://purrr.tidyverse.org), (see also: simple benchmark
37 | results plot below) including use of `~` and `.x`, without all the
38 | dependencies. In other words, use **{dapr}** when you want a purrr-like
39 | experience but you need a lightweight solution.
40 |
41 |
42 |
43 |
44 |
45 |
vap
53 | for **vectors**
54 | - lap
55 | for **lists**
56 | - dap
57 | for **data frames**
58 |
59 | Common inputs:
60 |
61 | - `.data` Input object–numeric, character, list, data frame, etc.–over
62 | which elements will be iterated. If matrix or data frame, each
63 | column will be treated as the elements which are to be iterated
64 | over.
65 | - `.f` Function to apply to each element of input object. This can be
66 | written as a single function name e.g., `mean`, a formula-like
67 | function call where `.x` is assumed to be the iterated over element
68 | of input data e.g., `~ mean(.x)`, or an in-line function definition
69 | e.g., `function(x) mean(x)`.
70 |
71 | ### Vectors
72 |
73 | Functions that apply expressions to input data objects and return atomic
74 | vectors e.g., numeric (double), character, logical.
75 |
76 | - **`vap_dbl()`** Iterate and return **numeric** vector.
77 | - **`vap_int()`** Iterate and return **integer** vector.
78 | - **`vap_lgl()`** Iterate and return **logical** vector.
79 | - **`vap_chr()`** Iterate and return **character** vector.
80 |
81 |
82 |
83 | ``` r
84 | ## create data
85 | set.seed(2018)
86 | d <- replicate(5, rnorm(10), simplify = FALSE)
87 | e <- replicate(5, sample(letters, 10), simplify = FALSE)
88 |
89 | ## numeric
90 | vap_dbl(d, ~ mean(.x))
91 | #> [1] 0.26934527 -0.55232322 0.05559290 -0.06253258 -0.11183760
92 |
93 | ## integer
94 | vap_int(d, length)
95 | #> [1] 10 10 10 10 10
96 |
97 | ## logical
98 | vap_lgl(d, ~ max(.x) > 3)
99 | #> [1] FALSE FALSE FALSE FALSE FALSE
100 |
101 | ## character
102 | vap_chr(e, paste, collapse = "")
103 | #> [1] "hizjpgcexk" "rbeovimtxh" "ujrimwgvzs" "euwrlytgbj" "qkrhylgmnx"
104 | ```
105 |
106 | ### Lists
107 |
108 | Function(s) that apply expressions to input data objects and return
109 | lists.
110 |
111 | - **`lap()`** Iterate and return a **list** vector.
112 |
113 |
114 |
115 | ``` r
116 | ## list of strings
117 | lap(e[1:2], ~ paste0(.x, "."))
118 | #> [[1]]
119 | #> [1] "h." "i." "z." "j." "p." "g." "c." "e." "x." "k."
120 | #>
121 | #> [[2]]
122 | #> [1] "r." "b." "e." "o." "v." "i." "m." "t." "x." "h."
123 | ```
124 |
125 | - **`ilap()`** Iterate over sequence length `.i` (instead of `.x`) and
126 | return a **list** vector.
127 |
128 |
129 |
130 | ``` r
131 | ## list of strings
132 | ilap(1:4, ~ paste0(letters[.i], rev(LETTERS)[.i]))
133 | #> [[1]]
134 | #> [1] "aZ"
135 | #>
136 | #> [[2]]
137 | #> [1] "bY"
138 | #>
139 | #> [[3]]
140 | #> [1] "cX"
141 | #>
142 | #> [[4]]
143 | #> [1] "dW"
144 | ```
145 |
146 | ### Data frames
147 |
148 | Functions that apply expressions to input data objects and return data
149 | frames.
150 |
151 | - **`dap*()`** Iterate and return a **data frame**
152 | - **`dapc()`** Iterate over **columns**
153 | - **`dapr()`** Iterate over **rows**
154 | - **`dap*_if()`** Conditionally iterate
155 | - **`dapc_if()`** Conditionally iterate over **columns**
156 | - **`dapr_if()`** Conditionally iterate over **rows**
157 |
158 |
159 |
160 | ``` r
161 | ## some data
162 | d <- data.frame(
163 | a = letters[1:3],
164 | b = rnorm(3),
165 | c = rnorm(3),
166 | stringsAsFactors = FALSE
167 | )
168 |
169 | ## column explicit (same as dap)
170 | dapc(d[-1], ~ round(.x, 2))
171 | #> b c
172 | #> 1 -0.50 -0.09
173 | #> 2 -1.87 1.08
174 | #> 3 0.74 -1.36
175 |
176 | ## rows
177 | dapr(d[-1], round, 3)
178 | #> b c
179 | #> 1 -0.499 -0.089
180 | #> 2 -1.869 1.081
181 | #> 3 0.743 -1.365
182 |
183 | ## conditional COLUMNS
184 | dapc_if(d, is.numeric, ~ round(.x, 4))
185 | #> a b c
186 | #> 1 a -0.4994 -0.0892
187 | #> 2 b -1.8686 1.0812
188 | #> 3 c 0.7434 -1.3646
189 |
190 | ## conditional ROWS
191 | dapr_if(d[-1], ~ sum(.x) >= -.7, ~ round(.x, 0))
192 | #> b c
193 | #> 1 0.000000 0.000000
194 | #> 2 -1.868615 1.081164
195 | #> 3 1.000000 -1.000000
196 | ```
197 |
--------------------------------------------------------------------------------
/_pkgdown.yml:
--------------------------------------------------------------------------------
1 | destination: docs
2 |
3 | url: https://dapr.mikewk.com
4 |
5 | template:
6 | ganalytics: "UA-124886828-1"
7 |
8 | authors:
9 | Michael W. Kearney:
10 | href: https://mikewk.com
11 | navbar:
12 | right:
13 | - icon: fa-github fa-lg
14 | href: https://github.com/mkearney/dapr
15 |
--------------------------------------------------------------------------------
/codecov.yml:
--------------------------------------------------------------------------------
1 | comment: false
2 |
3 | coverage:
4 | status:
5 | project:
6 | default:
7 | target: auto
8 | threshold: 1%
9 | patch:
10 | default:
11 | target: auto
12 | threshold: 1%
13 |
--------------------------------------------------------------------------------
/cran-comments.md:
--------------------------------------------------------------------------------
1 | ## Test environments
2 | * local OS X install, R 3.5.3
3 | * ubuntu 14.04 (on travis-ci), R 3.5.3
4 | * win-builder (devel and release)
5 |
6 | ## R CMD check results
7 |
8 | 0 errors | 0 warnings | 0 notes
9 |
--------------------------------------------------------------------------------
/dapr.Rproj:
--------------------------------------------------------------------------------
1 | Version: 1.0
2 |
3 | RestoreWorkspace: No
4 | SaveWorkspace: No
5 | AlwaysSaveHistory: Default
6 |
7 | EnableCodeIndexing: Yes
8 | UseSpacesForTab: Yes
9 | NumSpacesForTab: 2
10 | Encoding: UTF-8
11 |
12 | RnwWeave: Sweave
13 | LaTeX: pdfLaTeX
14 |
15 | AutoAppendNewline: Yes
16 | StripTrailingWhitespace: Yes
17 |
18 | BuildType: Package
19 | PackageUseDevtools: Yes
20 | PackageInstallArgs: --no-multiarch --with-keep.source
21 | PackageRoxygenize: rd,collate,namespace
22 |
--------------------------------------------------------------------------------
/docs/CNAME:
--------------------------------------------------------------------------------
1 | dapr.mikewk.com
2 |
--------------------------------------------------------------------------------
/docs/apple-touch-icon-120x120.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mkearney/dapr/744eb7e615d32fa97addc214b8c32528e36dfe36/docs/apple-touch-icon-120x120.png
--------------------------------------------------------------------------------
/docs/apple-touch-icon-152x152.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mkearney/dapr/744eb7e615d32fa97addc214b8c32528e36dfe36/docs/apple-touch-icon-152x152.png
--------------------------------------------------------------------------------
/docs/apple-touch-icon-180x180.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mkearney/dapr/744eb7e615d32fa97addc214b8c32528e36dfe36/docs/apple-touch-icon-180x180.png
--------------------------------------------------------------------------------
/docs/apple-touch-icon-60x60.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mkearney/dapr/744eb7e615d32fa97addc214b8c32528e36dfe36/docs/apple-touch-icon-60x60.png
--------------------------------------------------------------------------------
/docs/apple-touch-icon-76x76.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mkearney/dapr/744eb7e615d32fa97addc214b8c32528e36dfe36/docs/apple-touch-icon-76x76.png
--------------------------------------------------------------------------------
/docs/apple-touch-icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mkearney/dapr/744eb7e615d32fa97addc214b8c32528e36dfe36/docs/apple-touch-icon.png
--------------------------------------------------------------------------------
/docs/authors.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 | Michael W. Kearney. Author, maintainer. 
120 |
Dependency-free purrr-like apply/map/iterate functions
96 |Install the development version from Github with:
100 |
93 | ## install remotes pkg if not already
101 | if (!requireNamespace("remotes", quietly = TRUE)) {
102 | install.packages("remotes")
103 | }
104 |
105 | ## install from github
106 | remotes::install_github("mkearney/dapr"){dapr} provides the ease and consistency of {purrr}, (see also: simple benchmark results plot below) including use of ~ and .x, without all the dependencies. In other words, use {dapr} when you want a purrr-like experience but you need a lightweight solution.
113 |
Function names use the convention *ap() where * is the first letter of output data type.
vap for vectors
122 | lap for lists
125 | dap for data frames
128 | Common inputs:
131 |.data Input object–numeric, character, list, data frame, etc.–over which elements will be iterated. If matrix or data frame, each column will be treated as the elements which are to be iterated over..f Function to apply to each element of input object. This can be written as a single function name e.g., mean, a formula-like function call where .x is assumed to be the iterated over element of input data e.g., ~ mean(.x), or an in-line function definition e.g., function(x) mean(x).Functions that apply expressions to input data objects and return atomic vectors e.g., numeric (double), character, logical.
141 |vap_dbl() Iterate and return numeric vector.vap_int() Iterate and return integer vector.vap_lgl() Iterate and return logical vector.vap_chr() Iterate and return character vector.## create data
152 | set.seed(2018)
153 | d <- replicate(5, rnorm(10), simplify = FALSE)
154 | e <- replicate(5, sample(letters, 10), simplify = FALSE)
155 |
156 | ## numeric
157 | vap_dbl(d, ~ mean(.x))
158 | #> [1] 0.26934527 -0.55232322 0.05559290 -0.06253258 -0.11183760
159 |
160 | ## integer
161 | vap_int(d, length)
162 | #> [1] 10 10 10 10 10
163 |
164 | ## logical
165 | vap_lgl(d, ~ max(.x) > 3)
166 | #> [1] FALSE FALSE FALSE FALSE FALSE
167 |
168 | ## character
169 | vap_chr(e, paste, collapse = "")
170 | #> [1] "hizjpgcexk" "rbeovimtxh" "ujrimwgvzs" "euwrlytgbj" "qkrhylgmnx"Function(s) that apply expressions to input data objects and return lists.
176 |lap() Iterate and return a list vector.## list of strings
181 | lap(e[1:2], ~ paste0(.x, "."))
182 | #> [[1]]
183 | #> [1] "h." "i." "z." "j." "p." "g." "c." "e." "x." "k."
184 | #>
185 | #> [[2]]
186 | #> [1] "r." "b." "e." "o." "v." "i." "m." "t." "x." "h."ilap() Iterate over sequence length .i (instead of .x) and return a list vector.Functions that apply expressions to input data objects and return data frames.
209 |dap*() Iterate and return a data frame
212 |
220 | dap*_if() Conditionally iterate
223 |
231 | ## some data
234 | d <- data.frame(
235 | a = letters[1:3],
236 | b = rnorm(3),
237 | c = rnorm(3),
238 | stringsAsFactors = FALSE
239 | )
240 |
241 | ## column explicit (same as dap)
242 | dapc(d[-1], ~ round(.x, 2))
243 | #> b c
244 | #> 1 -0.50 -0.09
245 | #> 2 -1.87 1.08
246 | #> 3 0.74 -1.36
247 |
248 | ## rows
249 | dapr(d[-1], round, 3)
250 | #> b c
251 | #> 1 -0.499 -0.089
252 | #> 2 -1.869 1.081
253 | #> 3 0.743 -1.365
254 |
255 | ## conditional COLUMNS
256 | dapc_if(d, is.numeric, ~ round(.x, 4))
257 | #> a b c
258 | #> 1 a -0.4994 -0.0892
259 | #> 2 b -1.8686 1.0812
260 | #> 3 c 0.7434 -1.3646
261 |
262 | ## conditional ROWS
263 | dapr_if(d[-1], ~ sum(.x) >= -.7, ~ round(.x, 0))
264 | #> b c
265 | #> 1 0.000000 0.000000
266 | #> 2 -1.868615 1.081164
267 | #> 3 1.000000 -1.000000NEWS.md
116 | lapr(), vapc_chr(), etc.NEWS.md file to track changes to the package.lap(), vap_*(), and dap*() functions.Functions that apply expressions to input data objects and return data 129 | frames.
130 |dapc: Apply function to columns of a data frame.
131 |dapr: Apply function to rows of a data frame.
132 |dapc_if: Apply function to certain columns of a data frame.
133 |dapr_if: Apply function to certain rows of a data frame.
134 | 135 |dapc(.data, .f, ...) 138 | 139 | dapr(.data, .f, ...) 140 | 141 | dapc_if(.data, .predicate, .f, ...) 142 | 143 | dapr_if(.data, .predicate, .f, ...)144 | 145 |
| .data | 150 |Data frame input. |
151 |
|---|---|
| .f | 154 |Function to apply to element (columns or rows). This can be written
155 | as a single function name e.g., |
159 |
| ... | 162 |Other values passed to function call. |
163 |
| .predicate | 166 |Logical vector or expression evaluating to a logical vector.
167 | If not a logical vector, this can be written as a single function name
168 | e.g., The resulting logical vector is used to determine which elements (rows or 175 | columns) to iterate over with the .f function/expression. |
176 |
A data frame
182 | 183 |ilap: Iterate over sequence length of input and return list(s)
124 | 125 |ilap(.data, .f, ...)128 | 129 |
| .data | 134 |Object representing the sequence length, used as ".i" in the .f 135 | expression. If matrix or data frame, sequence length will be determined by 136 | the number of columns. If integer, then it will be passed directly onto 137 | function call, otherwise the object will be converted into a sequence from 138 | 1 to the length of the object. |
139 |
|---|---|
| .f | 142 |Function to apply to each element (as an integer position) of input
143 | object. This can be written as a single function name e.g., |
147 |
| ... | 150 |Other values passed to function call. |
151 |
A list
157 | 158 |Other lap: lap
231 |#> [[1]] 167 | #> [1] "aZ" 168 | #> 169 | #> [[2]] 170 | #> [1] "bY" 171 | #> 172 | #> [[3]] 173 | #> [1] "cX" 174 | #> 175 | #> [[4]] 176 | #> [1] "dW" 177 | #> 178 | #> [[5]] 179 | #> [1] "eV" 180 | #> 181 | #> [[6]] 182 | #> [1] "fU" 183 | #> 184 | #> [[7]] 185 | #> [1] "gT" 186 | #> 187 | #> [[8]] 188 | #> [1] "hS" 189 | #> 190 | #> [[9]] 191 | #> [1] "iR" 192 | #> 193 | #> [[10]] 194 | #> [1] "jQ" 195 | #>#> [[1]] 198 | #> [1] "Mazda RX4" "2.62" 199 | #> 200 | #> [[2]] 201 | #> [1] "Mazda RX4 Wag" "2.875" 202 | #> 203 | #> [[3]] 204 | #> [1] "Datsun 710" "2.32" 205 | #> 206 | #> [[4]] 207 | #> [1] "Hornet 4 Drive" "3.215" 208 | #> 209 | #> [[5]] 210 | #> [1] "Hornet Sportabout" "3.44" 211 | #> 212 | #> [[6]] 213 | #> [1] "Valiant" "3.46" 214 | #> 215 | #> [[7]] 216 | #> [1] "Duster 360" "3.57" 217 | #> 218 | #> [[8]] 219 | #> [1] "Merc 240D" "3.19" 220 | #> 221 | #> [[9]] 222 | #> [1] "Merc 230" "3.15" 223 | #> 224 | #> [[10]] 225 | #> [1] "Merc 280" "3.44" 226 | #> 227 | #> [[11]] 228 | #> [1] "Merc 280C" "3.44" 229 | #>230 |
Function(s) that apply expressions to input data objects and return lists.
127 |lap: Iterate over input and return list(s)
128 |lapr: Iterate over input rows and return list(s)
129 |lapr: Iterate over input columbs and return list(s)
130 | 131 |lap(.data, .f, ...) 134 | 135 | lapr(.data, .f, ...) 136 | 137 | lapc(.data, .f, ...) 138 | 139 | lap2(.x, .y, .f, ...)140 | 141 |
| .data | 146 |Input object–numeric, character, list, data frame, etc.–over 147 | which elements will be iterated. If matrix or data frame, each 148 | column will be treated as the elements which are to be iterated over. |
149 |
|---|---|
| .f | 152 |Function to apply to each element of input object. This can be
153 | written as a single function name e.g., |
157 |
| ... | 160 |Other values passed to function call. |
161 |
| .x | 164 |First data vector input (for lap2) |
165 |
| .y | 168 |Second data vector input (for lap2) |
169 |
A list
175 | 176 |377 |#> [[1]] 186 | #> [1] "a." 187 | #> 188 | #> [[2]] 189 | #> [1] "b." 190 | #> 191 | #> [[3]] 192 | #> [1] "c." 193 | #> 194 | #> [[4]] 195 | #> [1] "d." 196 | #> 197 | #> [[5]] 198 | #> [1] "e." 199 | #> 200 | #> [[6]] 201 | #> [1] "f." 202 | #> 203 | #> [[7]] 204 | #> [1] "g." 205 | #> 206 | #> [[8]] 207 | #> [1] "h." 208 | #> 209 | #> [[9]] 210 | #> [1] "i." 211 | #> 212 | #> [[10]] 213 | #> [1] "j." 214 | #> 215 | #> [[11]] 216 | #> [1] "k." 217 | #> 218 | #> [[12]] 219 | #> [1] "l." 220 | #> 221 | #> [[13]] 222 | #> [1] "m." 223 | #> 224 | #> [[14]] 225 | #> [1] "n." 226 | #> 227 | #> [[15]] 228 | #> [1] "o." 229 | #> 230 | #> [[16]] 231 | #> [1] "p." 232 | #> 233 | #> [[17]] 234 | #> [1] "q." 235 | #> 236 | #> [[18]] 237 | #> [1] "r." 238 | #> 239 | #> [[19]] 240 | #> [1] "s." 241 | #> 242 | #> [[20]] 243 | #> [1] "t." 244 | #> 245 | #> [[21]] 246 | #> [1] "u." 247 | #> 248 | #> [[22]] 249 | #> [1] "v." 250 | #> 251 | #> [[23]] 252 | #> [1] "w." 253 | #> 254 | #> [[24]] 255 | #> [1] "x." 256 | #> 257 | #> [[25]] 258 | #> [1] "y." 259 | #> 260 | #> [[26]] 261 | #> [1] "z." 262 | #>263 | ## return list of columns 264 | lap(mtcars[1:5, ], as.character)#> $mpg 265 | #> [1] "21" "21" "22.8" "21.4" "18.7" 266 | #> 267 | #> $cyl 268 | #> [1] "6" "6" "4" "6" "8" 269 | #> 270 | #> $disp 271 | #> [1] "160" "160" "108" "258" "360" 272 | #> 273 | #> $hp 274 | #> [1] "110" "110" "93" "110" "175" 275 | #> 276 | #> $drat 277 | #> [1] "3.9" "3.9" "3.85" "3.08" "3.15" 278 | #> 279 | #> $wt 280 | #> [1] "2.62" "2.875" "2.32" "3.215" "3.44" 281 | #> 282 | #> $qsec 283 | #> [1] "16.46" "17.02" "18.61" "19.44" "17.02" 284 | #> 285 | #> $vs 286 | #> [1] "0" "0" "1" "1" "0" 287 | #> 288 | #> $am 289 | #> [1] "1" "1" "1" "0" "0" 290 | #> 291 | #> $gear 292 | #> [1] "4" "4" "4" "3" "3" 293 | #> 294 | #> $carb 295 | #> [1] "4" "4" "1" "1" "2" 296 | #>#> [[1]] 299 | #> [1] "aAaA" 300 | #> 301 | #> [[2]] 302 | #> [1] "bBbB" 303 | #> 304 | #> [[3]] 305 | #> [1] "cCcC" 306 | #> 307 | #> [[4]] 308 | #> [1] "dDdD" 309 | #> 310 | #> [[5]] 311 | #> [1] "eEeE" 312 | #> 313 | #> [[6]] 314 | #> [1] "fFfF" 315 | #> 316 | #> [[7]] 317 | #> [1] "gGgG" 318 | #> 319 | #> [[8]] 320 | #> [1] "hHhH" 321 | #> 322 | #> [[9]] 323 | #> [1] "iIiI" 324 | #> 325 | #> [[10]] 326 | #> [1] "jJjJ" 327 | #> 328 | #> [[11]] 329 | #> [1] "kKkK" 330 | #> 331 | #> [[12]] 332 | #> [1] "lLlL" 333 | #> 334 | #> [[13]] 335 | #> [1] "mMmM" 336 | #> 337 | #> [[14]] 338 | #> [1] "nNnN" 339 | #> 340 | #> [[15]] 341 | #> [1] "oOoO" 342 | #> 343 | #> [[16]] 344 | #> [1] "pPpP" 345 | #> 346 | #> [[17]] 347 | #> [1] "qQqQ" 348 | #> 349 | #> [[18]] 350 | #> [1] "rRrR" 351 | #> 352 | #> [[19]] 353 | #> [1] "sSsS" 354 | #> 355 | #> [[20]] 356 | #> [1] "tTtT" 357 | #> 358 | #> [[21]] 359 | #> [1] "uUuU" 360 | #> 361 | #> [[22]] 362 | #> [1] "vVvV" 363 | #> 364 | #> [[23]] 365 | #> [1] "wWwW" 366 | #> 367 | #> [[24]] 368 | #> [1] "xXxX" 369 | #> 370 | #> [[25]] 371 | #> [1] "yYyY" 372 | #> 373 | #> [[26]] 374 | #> [1] "zZzZ" 375 | #>376 |
Functions that apply expressions to input objects and return atomic vectors 129 | e.g., numeric (double), integer, character, logical.
130 |vap_dbl: Iterate over input and return double(s)
131 |vap_chr: Iterate over input and return character(s)
132 |vap_lgl: Iterate over input and return logical(s)
133 |vap_int: Iterate over input and return integer(s)
134 | 135 |vap_dbl(.data, .f, ...) 138 | 139 | vap_chr(.data, .f, ...) 140 | 141 | vap_lgl(.data, .f, ...) 142 | 143 | vap_int(.data, .f, ...)144 | 145 |
| .data | 150 |Input object–numeric, character, list, data frame, etc.–over 151 | which elements will be iterated. If matrix or data frame, each 152 | column will be treated as an element. |
153 |
|---|---|
| .f | 156 |Action to apply to each element of
|
165 |
| ... | 168 |Other values passed to function call. |
169 |
A double vector
175 |A character vector
176 |A logical vector
177 |An integer vector
178 | 179 |202 |#> a b c d e f g h i j k l m n o p 189 | #> "a." "b." "c." "d." "e." "f." "g." "h." "i." "j." "k." "l." "m." "n." "o." "p." 190 | #> q r s t u v w x y z 191 | #> "q." "r." "s." "t." "u." "v." "w." "x." "y." "z."#> [1] -1.400 0.255 -2.437 -0.006#> a b c d e f g h i j k l m 196 | #> TRUE FALSE FALSE FALSE TRUE FALSE FALSE FALSE TRUE FALSE FALSE FALSE FALSE 197 | #> n o p q r s t u v w x y z 198 | #> FALSE TRUE FALSE FALSE FALSE FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE#> [1] 9 4 5 8 2 6 7 3 1 10201 |
Functions that apply expressions to the columns of input objects and return 129 | atomic vectors e.g., numeric (double), integer, character, logical.
130 |vapc_chr: Iterate over input columns and return character(s)
131 |vapc_dbl: Iterate over input columns and return numeric(s)
132 |vapc_lgl: Iterate over input columns and return logical(s)
133 |vapc_int: Iterate over input columns and return integer(s)
134 | 135 |vapc_chr(.data, .f, ...) 138 | 139 | vapc_dbl(.data, .f, ...) 140 | 141 | vapc_lgl(.data, .f, ...) 142 | 143 | vapc_int(.data, .f, ...)144 | 145 |
| .data | 150 |Input object–must be two-dimensional (e.g., matrix, data.frame) 151 | –over which the second dimension (columns) will be iterated |
152 |
|---|---|
| .f | 155 |Action to apply to each element of
|
164 |
| ... | 167 |Other values passed to function call. |
168 |
A character vector
174 |A numeric vector
175 |A logical vector
176 |An integer vector
177 | 178 |Functions that apply expressions to the rows of input objects and return 129 | atomic vectors e.g., numeric (double), integer, character, logical.
130 |vapr_chr: Iterate over input rows and return character(s)
131 |vapr_dbl: Iterate over input rows and return numeric(s)
132 |vapr_lgl: Iterate over input rows and return logical(s)
133 |vapr_int: Iterate over input rows and return integer(s)
134 | 135 |vapr_chr(.data, .f, ...) 138 | 139 | vapr_dbl(.data, .f, ...) 140 | 141 | vapr_lgl(.data, .f, ...) 142 | 143 | vapr_int(.data, .f, ...)144 | 145 |
| .data | 150 |Input object–must be two-dimensional (e.g., matrix, data.frame) 151 | –over which the first dimension (rows) will be iterated |
152 |
|---|---|
| .f | 155 |Action to apply to each element of
|
164 |
| ... | 167 |Other values passed to function call. |
168 |
A character vector
174 |A numeric vector
175 |A logical vector
176 |An integer vector
177 | 178 |