Format with latest Air (for one sided formula tweaks) (#299)

Author: DavisVaughan

tests/testthat/test-furrr-options.R

@@ -71,11 +71,11 @@ test_that("can selectively export packages on multisession", {
   opts <- furrr_options(packages = "dplyr")
 
   expect_error(
-    future_map(1:2, ~tibble(x = .x))
+    future_map(1:2, ~ tibble(x = .x))
   )
 
   expect_identical(
-    future_map(1:2, ~tibble(x = .x), .options = opts),
+    future_map(1:2, ~ tibble(x = .x), .options = opts),
     list(dplyr::tibble(x = 1L), dplyr::tibble(x = 2L))
   )
 })

tests/testthat/test-future-imap.R

@@ -1,46 +1,46 @@
 furrr_test_that("imap functions work with unnamed input", {
   expect_identical(future_imap(1:2, ~.y), list(1L, 2L))
-  expect_identical(future_imap_chr(1:2, ~as.character(.y)), c("1", "2"))
+  expect_identical(future_imap_chr(1:2, ~ as.character(.y)), c("1", "2"))
   expect_identical(future_imap_int(1:2, ~.y), c(1L, 2L))
   expect_identical(future_imap_dbl(1:2, ~.y), c(1, 2))
-  expect_identical(future_imap_lgl(1:2, ~identical(.y, 1L)), c(TRUE, FALSE))
-  expect_identical(future_imap_raw(1:2, ~raw(1)), raw(2))
+  expect_identical(future_imap_lgl(1:2, ~ identical(.y, 1L)), c(TRUE, FALSE))
+  expect_identical(future_imap_raw(1:2, ~ raw(1)), raw(2))
   expect_identical(
-    future_imap_dfr(1:2, ~data.frame(x = .y)),
+    future_imap_dfr(1:2, ~ data.frame(x = .y)),
     data.frame(x = c(1L, 2L))
   )
   expect_identical(
-    future_imap_dfc(1:2, ~vctrs::new_data_frame(set_names(list(1), .y))),
+    future_imap_dfc(1:2, ~ vctrs::new_data_frame(set_names(list(1), .y))),
     vctrs::new_data_frame(list(`1` = 1, `2` = 1))
   )
 })
 
 furrr_test_that("imap functions work with named input", {
   x <- set_names(1:2, c("x", "y"))
   expect_identical(future_imap(x, ~.y), list(x = "x", y = "y"))
-  expect_identical(future_imap_chr(x, ~as.character(.y)), c(x = "x", y = "y"))
+  expect_identical(future_imap_chr(x, ~ as.character(.y)), c(x = "x", y = "y"))
   expect_identical(
-    future_imap_int(x, ~if (.y == "x") 1L else 2L),
+    future_imap_int(x, ~ if (.y == "x") 1L else 2L),
     c(x = 1L, y = 2L)
   )
   expect_identical(
-    future_imap_dbl(x, ~if (.y == "x") 1 else 2),
+    future_imap_dbl(x, ~ if (.y == "x") 1 else 2),
     c(x = 1, y = 2)
   )
   expect_identical(
-    future_imap_lgl(x, ~if (.y == "x") TRUE else FALSE),
+    future_imap_lgl(x, ~ if (.y == "x") TRUE else FALSE),
     c(x = TRUE, y = FALSE)
   )
   expect_identical(
-    future_imap_raw(x, ~if (.y == "x") as.raw(1) else as.raw(2)),
+    future_imap_raw(x, ~ if (.y == "x") as.raw(1) else as.raw(2)),
     set_names(as.raw(c(1L, 2L)), c("x", "y"))
   )
   expect_identical(
-    future_imap_dfr(x, ~data.frame(x = .y)),
+    future_imap_dfr(x, ~ data.frame(x = .y)),
     data.frame(x = c("x", "y"))
   )
   expect_identical(
-    future_imap_dfc(x, ~vctrs::new_data_frame(set_names(list(1), .y))),
+    future_imap_dfc(x, ~ vctrs::new_data_frame(set_names(list(1), .y))),
     vctrs::new_data_frame(list(x = 1, y = 1))
   )
 })

tests/testthat/test-future-map.R

@@ -78,17 +78,17 @@ furrr_test_that("future_map_dfr() works", {
   x <- c("a", "b", "c")
 
   expect_identical(
-    future_map_dfr(x, ~data.frame(x = .x)),
-    map_dfr(x, ~data.frame(x = .x))
+    future_map_dfr(x, ~ data.frame(x = .x)),
+    map_dfr(x, ~ data.frame(x = .x))
   )
 })
 
 furrr_test_that("future_map_dfc() works", {
   x <- c("a", "b", "c")
 
   expect_identical(
-    future_map_dfc(x, ~as.data.frame(set_names(list(1), .x))),
-    map_dfc(x, ~as.data.frame(set_names(list(1), .x)))
+    future_map_dfc(x, ~ as.data.frame(set_names(list(1), .x))),
+    map_dfc(x, ~ as.data.frame(set_names(list(1), .x)))
   )
 })
 
@@ -128,22 +128,22 @@ furrr_test_that("future_map_if() works", {
   x <- list("a", "b", "c")
 
   expect_identical(
-    future_map_if(x, ~.x %in% c("a", "c"), ~3),
-    map_if(x, ~.x %in% c("a", "c"), ~3)
+    future_map_if(x, ~ .x %in% c("a", "c"), ~3),
+    map_if(x, ~ .x %in% c("a", "c"), ~3)
   )
 })
 
 furrr_test_that("names of `.x` are retained", {
   x <- list(a = "a", b = "b", c = "c")
-  expect_named(future_map_if(x, ~.x %in% c("a", "c"), ~3), c("a", "b", "c"))
+  expect_named(future_map_if(x, ~ .x %in% c("a", "c"), ~3), c("a", "b", "c"))
 })
 
 furrr_test_that("`.else` can be used", {
   x <- list("a", "b", "c")
 
   expect_identical(
-    future_map_if(x, ~.x %in% c("a", "c"), ~3, .else = ~-1),
-    map_if(x, ~.x %in% c("a", "c"), ~3, .else = ~-1)
+    future_map_if(x, ~ .x %in% c("a", "c"), ~3, .else = ~ -1),
+    map_if(x, ~ .x %in% c("a", "c"), ~3, .else = ~ -1)
   )
 })
 
@@ -156,7 +156,7 @@ furrr_test_that("Calling `~` from within `.f` works", {
     list(c = 5, d = 7)
   )
 
-  expect_identical(future_map(x, ~map(.x, ~.x)), x)
+  expect_identical(future_map(x, ~ map(.x, ~.x)), x)
 })
 
 furrr_test_that("Calling `~` from within `.f` inside a `mutate()` works (#7, #123)", {
@@ -168,7 +168,7 @@ furrr_test_that("Calling `~` from within `.f` inside a `mutate()` works (#7, #12
   df <- dplyr::tibble(x = x)
 
   expect_identical(
-    dplyr::mutate(df, x = future_map(x, ~map(.x, ~.x))),
+    dplyr::mutate(df, x = future_map(x, ~ map(.x, ~.x))),
     df
   )
 })
@@ -178,11 +178,11 @@ furrr_test_that("globals in `.x` are found (#16)", {
 
   x <- list(c(1, 2, NA), c(2, 3, 4))
 
-  fns1 <- map(x, ~purrr::partial(fn, x = .x))
-  fns2 <- map(x, ~function() fn(.x))
+  fns1 <- map(x, ~ purrr::partial(fn, x = .x))
+  fns2 <- map(x, ~ function() fn(.x))
 
-  expect_identical(future_map_dbl(fns1, ~.x()), c(3, 9))
-  expect_identical(future_map_dbl(fns2, ~.x()), c(3, 9))
+  expect_identical(future_map_dbl(fns1, ~ .x()), c(3, 9))
+  expect_identical(future_map_dbl(fns2, ~ .x()), c(3, 9))
 })
 
 test_that("globals in `.x` are only exported to workers that use them", {
@@ -212,7 +212,7 @@ test_that("globals in `.x` are only exported to workers that use them", {
   x <- list(my_wrapper1, my_wrapper2)
 
   expect_identical(
-    future_map_lgl(.x = x, .f = ~.x(c(1, NA))),
+    future_map_lgl(.x = x, .f = ~ .x(c(1, NA))),
     c(TRUE, FALSE)
   )
 })

tests/testthat/test-future-map2.R

@@ -3,8 +3,8 @@
 
 furrr_test_that("future_map2() matches map2() for simple cases", {
   expect_identical(
-    future_map2(1:3, 4:6, ~.x + .y),
-    map2(1:3, 4:6, ~.x + .y)
+    future_map2(1:3, 4:6, ~ .x + .y),
+    map2(1:3, 4:6, ~ .x + .y)
   )
 })
 
@@ -27,8 +27,8 @@ furrr_test_that("future_map2_dbl() works", {
   y <- c(4, 5, 6)
 
   expect_identical(
-    future_map2_dbl(x, y, ~.x + .y),
-    map2_dbl(x, y, ~.x + .y)
+    future_map2_dbl(x, y, ~ .x + .y),
+    map2_dbl(x, y, ~ .x + .y)
   )
 })
 
@@ -37,8 +37,8 @@ furrr_test_that("future_map2_int() works", {
   y <- c(4L, 5L, 6L)
 
   expect_identical(
-    future_map2_int(x, y, ~.x + .y),
-    map2_int(x, y, ~.x + .y)
+    future_map2_int(x, y, ~ .x + .y),
+    map2_int(x, y, ~ .x + .y)
   )
 })
 
@@ -47,8 +47,8 @@ furrr_test_that("future_map2_lgl() works", {
   y <- c(FALSE, TRUE, TRUE)
 
   expect_identical(
-    future_map2_lgl(x, y, ~.x || .y),
-    map2_lgl(x, y, ~.x || .y)
+    future_map2_lgl(x, y, ~ .x || .y),
+    map2_lgl(x, y, ~ .x || .y)
   )
 })
 
@@ -86,8 +86,8 @@ furrr_test_that("future_map2_dfr() works", {
   y <- c("d", "e", "f")
 
   expect_identical(
-    future_map2_dfr(x, y, ~data.frame(x = .x, y = .y)),
-    map2_dfr(x, y, ~data.frame(x = .x, y = .y))
+    future_map2_dfr(x, y, ~ data.frame(x = .x, y = .y)),
+    map2_dfr(x, y, ~ data.frame(x = .x, y = .y))
   )
 })
 
@@ -96,8 +96,8 @@ furrr_test_that("future_map2_dfc() works", {
   y <- c("d", "e", "f")
 
   expect_identical(
-    future_map2_dfc(x, y, ~as.data.frame(set_names(list(.x), .y))),
-    map2_dfc(x, y, ~as.data.frame(set_names(list(.x), .y)))
+    future_map2_dfc(x, y, ~ as.data.frame(set_names(list(.x), .y))),
+    map2_dfc(x, y, ~ as.data.frame(set_names(list(.x), .y)))
   )
 })
 
@@ -118,34 +118,34 @@ furrr_test_that("atomic variants work with size zero input", {
 
 furrr_test_that("size one recycling works", {
   expect_identical(
-    future_map2(1, 1:2, ~c(.x, .y)),
+    future_map2(1, 1:2, ~ c(.x, .y)),
     list(c(1, 1), c(1, 2))
   )
 
   expect_identical(
-    future_map2(1:2, 1, ~c(.x, .y)),
+    future_map2(1:2, 1, ~ c(.x, .y)),
     list(c(1, 1), c(2, 1))
   )
 
   expect_identical(
-    future_map2(integer(), 1, ~c(.x, .y)),
+    future_map2(integer(), 1, ~ c(.x, .y)),
     list()
   )
 
   expect_identical(
-    future_map2(1, integer(), ~c(.x, .y)),
+    future_map2(1, integer(), ~ c(.x, .y)),
     list()
   )
 })
 
 furrr_test_that("generally can't recycle to size zero", {
   expect_error(
-    future_map2(1:2, integer(), ~c(.x, .y)),
+    future_map2(1:2, integer(), ~ c(.x, .y)),
     "Can't recycle"
   )
 
   expect_error(
-    future_map2(integer(), 1:2, ~c(.x, .y)),
+    future_map2(integer(), 1:2, ~ c(.x, .y)),
     "Can't recycle"
   )
 })
@@ -159,18 +159,18 @@ furrr_test_that("globals in `.x` and `.y` are found (#16)", {
 
   x <- list(c(1, 2, NA), c(2, 3, 4))
 
-  fns1 <- map(x, ~purrr::partial(fn1, x = .x))
-  fns2 <- map(x, ~purrr::partial(fn2, x = .x))
+  fns1 <- map(x, ~ purrr::partial(fn1, x = .x))
+  fns2 <- map(x, ~ purrr::partial(fn2, x = .x))
 
   expect_identical(
-    future_map2(fns1, fns2, ~c(.x(), .y())),
+    future_map2(fns1, fns2, ~ c(.x(), .y())),
     list(c(3, NA), c(9, 9))
   )
 })
 
 furrr_test_that("chunk balancing is correct after a recycle (#30)", {
   expect_identical(
-    future_map2(1, 1:4, ~c(.x, .y)),
+    future_map2(1, 1:4, ~ c(.x, .y)),
     list(c(1, 1), c(1, 2), c(1, 3), c(1, 4))
   )
 })

tests/testthat/test-future-modify.R

@@ -15,7 +15,7 @@ furrr_test_that("future_modify() is not stable when returning `NULL`", {
   expect_identical(
     future_modify(
       list(1, 2),
-      ~if (.x == 1) {
+      ~ if (.x == 1) {
         NULL
       } else {
         .x
@@ -65,35 +65,35 @@ furrr_test_that("future_modify_at() variants works", {
 # future_modify_if()
 
 furrr_test_that("future_modify_if() default works", {
-  expect_identical(future_modify_if(list(1, 2), ~.x == 1, ~3), list(3, 2))
+  expect_identical(future_modify_if(list(1, 2), ~ .x == 1, ~3), list(3, 2))
   expect_identical(
-    future_modify_if(data.frame(x = 1, y = 2), ~.x == 1, ~3),
+    future_modify_if(data.frame(x = 1, y = 2), ~ .x == 1, ~3),
     data.frame(x = 3, y = 2)
   )
 })
 
 furrr_test_that("future_modify_if() `.else` works for default", {
   expect_identical(
-    future_modify_if(list(1, 2, 1, 4), ~.x == 1, ~3, .else = ~4),
+    future_modify_if(list(1, 2, 1, 4), ~ .x == 1, ~3, .else = ~4),
     list(3, 4, 3, 4)
   )
 })
 
 furrr_test_that("future_modify_if() variants works", {
   expect_identical(
-    future_modify_if(c(1L, 2L, 3L), ~.x == 1L, ~2L, .else = ~3L),
+    future_modify_if(c(1L, 2L, 3L), ~ .x == 1L, ~2L, .else = ~3L),
     c(2L, 3L, 3L)
   )
   expect_identical(
-    future_modify_if(c(1, 2, 3), ~.x == 1, ~2, .else = ~3),
+    future_modify_if(c(1, 2, 3), ~ .x == 1, ~2, .else = ~3),
     c(2, 3, 3)
   )
   expect_identical(
-    future_modify_if(c("a", "b", "c"), ~.x == "a", toupper, .else = ~"d"),
+    future_modify_if(c("a", "b", "c"), ~ .x == "a", toupper, .else = ~"d"),
     c("A", "d", "d")
   )
   expect_identical(
-    future_modify_if(c(TRUE, FALSE, TRUE), ~.x == TRUE, ~TRUE, .else = ~NA),
+    future_modify_if(c(TRUE, FALSE, TRUE), ~ .x == TRUE, ~TRUE, .else = ~NA),
     c(TRUE, NA, TRUE)
   )
 })