# can control number of differences Code compare(x, y, max_diffs = 1) Output `old[[1]]`: "a" `new[[1]]`: "A" And 25 more differences ... --- Code compare(x, y, max_diffs = Inf) Output `old[[1]]`: "a" `new[[1]]`: "A" `old[[2]]`: "b" `new[[2]]`: "B" `old[[3]]`: "c" `new[[3]]`: "C" `old[[4]]`: "d" `new[[4]]`: "D" `old[[5]]`: "e" `new[[5]]`: "E" `old[[6]]`: "f" `new[[6]]`: "F" `old[[7]]`: "g" `new[[7]]`: "G" `old[[8]]`: "h" `new[[8]]`: "H" `old[[9]]`: "i" `new[[9]]`: "I" `old[[10]]`: "j" `new[[10]]`: "J" `old[[11]]`: "k" `new[[11]]`: "K" `old[[12]]`: "l" `new[[12]]`: "L" `old[[13]]`: "m" `new[[13]]`: "M" `old[[14]]`: "n" `new[[14]]`: "N" `old[[15]]`: "o" `new[[15]]`: "O" `old[[16]]`: "p" `new[[16]]`: "P" `old[[17]]`: "q" `new[[17]]`: "Q" `old[[18]]`: "r" `new[[18]]`: "R" `old[[19]]`: "s" `new[[19]]`: "S" `old[[20]]`: "t" `new[[20]]`: "T" `old[[21]]`: "u" `new[[21]]`: "U" `old[[22]]`: "v" `new[[22]]`: "V" `old[[23]]`: "w" `new[[23]]`: "W" `old[[24]]`: "x" `new[[24]]`: "X" `old[[25]]`: "y" `new[[25]]`: "Y" `old[[26]]`: "z" `new[[26]]`: "Z" --- Code compare(letters, LETTERS, max_diffs = 1) Output `old`: "a" and 25 more... `new`: "A" ... --- Code compare(letters, LETTERS, max_diffs = 10) Output `old`: "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" and 16 more... `new`: "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" ... --- Code compare(letters, LETTERS, max_diffs = 20) Output old | new [1] "a" - "A" [1] [2] "b" - "B" [2] [3] "c" - "C" [3] [4] "d" - "D" [4] [5] "e" - "E" [5] [6] "f" - "F" [6] [7] "g" - "G" [7] [8] "h" - "H" [8] [9] "i" - "I" [9] [10] "j" - "J" [10] [11] "k" - "K" [11] [12] "l" - "L" [12] [13] "m" - "M" [13] [14] "n" - "N" [14] [15] "o" - "O" [15] [16] "p" - "P" [16] [17] "q" - "Q" [17] [18] "r" - "R" [18] [19] "s" - "S" [19] [20] "t" - "T" [20] ... ... ... and 6 more ... --- Code compare(letters, LETTERS, max_diffs = Inf) Output old | new [1] "a" - "A" [1] [2] "b" - "B" [2] [3] "c" - "C" [3] [4] "d" - "D" [4] [5] "e" - "E" [5] [6] "f" - "F" [6] [7] "g" - "G" [7] [8] "h" - "H" [8] [9] "i" - "I" [9] [10] "j" - "J" [10] [11] "k" - "K" [11] [12] "l" - "L" [12] [13] "m" - "M" [13] [14] "n" - "N" [14] [15] "o" - "O" [15] [16] "p" - "P" [16] [17] "q" - "Q" [17] [18] "r" - "R" [18] [19] "s" - "S" [19] [20] "t" - "T" [20] [21] "u" - "U" [21] [22] "v" - "V" [22] [23] "w" - "W" [23] [24] "x" - "X" [24] [25] "y" - "Y" [25] [26] "z" - "Z" [26] # can optionally ignore selected attributes Code compare(x, y, ignore_attr = "a") Output `attr(old, 'b')` is absent `attr(new, 'b')` is a character vector ('b') # ignores S3 [[ methods Code x <- as.POSIXlt("2020-01-01") y <- as.POSIXlt("2020-01-02") compare(x, y) Output `old$mday`: 1 `new$mday`: 2 `old$wday`: 3 `new$wday`: 4 `old$yday`: 0 `new$yday`: 1 Code x <- package_version("1.0.0") y <- package_version("1.1.0") compare(x, y) Output `old[[1]]`: 1 0 0 `new[[1]]`: 1 1 0 # can optionally compare encoding Code compare(x, y) Output v No differences Code compare(x, y, ignore_encoding = FALSE) Output `Encoding(old)`: "latin1" "UTF-8" `Encoding(new)`: "UTF-8" "latin1" # lists compare by name, where possible Code # extra y compare(list("a", "b"), list("a", "b", "c")) Output `old` is length 2 `new` is length 3 `old[[3]]` is absent `new[[3]]` is a character vector ('c') Code compare(list(a = "a", b = "b"), list(a = "a", b = "b", c = "c")) Output `old` is length 2 `new` is length 3 `names(old)`: "a" "b" `names(new)`: "a" "b" "c" `old$c` is absent `new$c` is a character vector ('c') Code # extra x compare(list("a", "b", "c"), list("a", "b")) Output `old` is length 3 `new` is length 2 `old[[3]]` is a character vector ('c') `new[[3]]` is absent Code compare(list(a = "a", b = "b", c = "c"), list(a = "a", b = "b")) Output `old` is length 3 `new` is length 2 `names(old)`: "a" "b" "c" `names(new)`: "a" "b" `old$c` is a character vector ('c') `new$c` is absent Code # different order compare(list(a = "a", b = "b"), list(b = "b", a = "a")) Output `names(old)`: "a" "b" `names(new)`: "b" "a" Code # invalid names uses position compare(list(a = "a", "b"), list(a = "a", "c")) Output `old[[2]]`: "b" `new[[2]]`: "c" Code compare(list(a = "a", a = "b"), list(a = "a", a = "c")) Output `old[[2]]`: "b" `new[[2]]`: "c" # can request lists treated as maps Code compare_map(list(x = 1, y = 1, y = 2), list(x = 1, y = 1)) Output `old` is length 3 `new` is length 2 `names(old)`: "x" "y" "y" `names(new)`: "x" "y" `old[[3]]` is a double vector (2) `new[[3]]` is absent # can compare with `missing_arg()` Code compare(missing_arg(), missing_arg()) Output v No differences Code compare(missing_arg(), sym("a")) Output `old` is absent `new` is a symbol Code compare(sym("a"), missing_arg()) Output `old` is a symbol `new` is absent --- Code # when in a list symbol #79 compare(list(sym("a")), list()) Output `old` is length 1 `new` is length 0 `old[[1]]` is a symbol `new[[1]]` is absent Code compare(list(), list(sym("a"))) Output `old` is length 0 `new` is length 1 `old[[1]]` is absent `new[[1]]` is a symbol # comparing functions gives useful diffs Code # equal f1 <- (function(x = 1, y = 2) { }) f2 <- (function(x = 1, y = 2) { }) compare(f1, f2) Output v No differences Code f2 <- source(test_path("f2.R"), local = TRUE, keep.source = TRUE)$value compare(f1, f2) Output v No differences Code # pritimives compare(`[`, sum) Output `old` is `.Primitive("[")` `new` is `.Primitive("sum")` Code compare(sum, prod) Output `old` is `.Primitive("sum")` `new` is `.Primitive("prod")` Code # diff formals f3 <- (function(x = 1, y = 1, z = 1) { }) compare(f1, f3) Output `formals(old)` is length 2 `formals(new)` is length 3 `names(formals(old))`: "x" "y" `names(formals(new))`: "x" "y" "z" `formals(old)$y`: 2 `formals(new)$y`: 1 `formals(old)$z` is absent `formals(new)$z` is a double vector (1) Code # diff body f4 <- (function(x = 1, y = 2) { x + y }) compare(f1, f4) Output `body(old)`: `{` `}` `body(new)`: `{` ` x + y` `}` Code compare(f1, f4, ignore_srcref = FALSE) Output `attr(old, 'srcref')`: 2 8 2 33 8 33 2 2 `attr(new, 'srcref')`: 14 8 16 1 8 1 14 16 `attr(body(old), 'srcref')` is length 1 `attr(body(new), 'srcref')` is length 2 `attr(body(old), 'srcref')[[1]]`: 2 31 2 31 31 31 2 2 `attr(body(new), 'srcref')[[1]]`: 14 31 14 31 31 31 14 14 `attr(body(old), 'srcref')[[2]]` is absent `attr(body(new), 'srcref')[[2]]` is an S3 object of class <srcref>, an integer vector `attr(body(old), 'wholeSrcref')`: 1 0 2 33 0 33 1 2 `attr(body(new), 'wholeSrcref')`: 1 0 16 1 0 1 1 16 `body(old)`: `{` `}` `body(new)`: `{` ` x + y` `}` Code # diff environment environment(f1) <- base_env() environment(f2) <- global_env() compare(f1, f2) Output `environment(old)` is <env:package:base> `environment(new)` is <env:global> # can choose to compare srcrefs Code f1 <- f2 <- (function() { }) attr(f2, "srcref") <- "{ }" compare(f2, f1) Output v No differences Code compare(f2, f1, ignore_srcref = FALSE) Output `attr(old, 'srcref')` is a character vector ('{ }') `attr(new, 'srcref')` is an S3 object of class <srcref>, an integer vector # can compare atomic vectors Code compare(1:3, 10L + 1:3) Output `old`: 1 2 3 `new`: 11 12 13 Code compare(c(TRUE, FALSE, NA, TRUE), c(FALSE, FALSE, FALSE)) Output `old`: TRUE FALSE <NA> TRUE `new`: FALSE FALSE FALSE # can compare S3 objects Code compare(factor("a"), 1L) Output `old` is an S3 object of class <factor>, an integer vector `new` is an integer vector (1) Code compare(factor("a"), globalenv()) Output `old` is an S3 object of class <factor>, an integer vector `new` is an environment Code compare(factor("a"), as.Date("1970-01-02")) Output `old` is an S3 object of class <factor>, an integer vector `new` is an S3 object of class <Date>, a double vector Code compare(structure(function() { }, class = "foo"), factor("a")) Output `old` is an S3 object of class <foo>, a function `new` is an S3 object of class <factor>, an integer vector # can compare S4 objects Code # Non S4 compare(new("A", x = "1"), 1) Output `old` is an S4 object of class <A> `new` is a double vector (1) Code compare(new("A", x = "1"), globalenv()) Output `old` is an S4 object of class <A> `new` is an environment Code compare(new("A", x = "1"), factor("x")) Output `old` is an S4 object of class <A> `new` is an S3 object of class <factor>, an integer vector Code # S4 compare(new("A", x = "1"), new("A", x = "1")) Output v No differences Code compare(new("A", x = "1"), new("A", x = "2")) Output `old@x`: "1" `new@x`: "2" Code compare(new("A", x = "1"), new("B", x = "1")) Output `is(old)`: "A" `is(new)`: "B" "A" Code # S4 with extra attributes new <- old <- new("A", x = "1") attr(new, "bar") <- 2 compare(new, old) Output `attr(old, 'bar')` is a double vector (2) `attr(new, 'bar')` is absent # can compare R6 objects Code goofy <- R6::R6Class("goofy", public = list(initialize = function(x) self$x <- x, x = 10)) froofy <- R6::R6Class("froofy", inherit = goofy, public = list(y = 10)) # Non R6 compare(goofy$new(1), 1) Output `old` is an R6 object of class <goofy> `new` is a double vector (1) Code compare(goofy$new(1), globalenv()) Output `old` is an R6 object of class <goofy> `new` is an environment Code compare(goofy$new(1), factor("x")) Output `old` is an R6 object of class <goofy> `new` is an S3 object of class <factor>, an integer vector Code # R6 compare(goofy$new(1), goofy$new(1)) Output v No differences Code compare(goofy$new(1), goofy$new("a")) Output `old$x` is a double vector (1) `new$x` is a character vector ('a') Code compare(goofy$new(1), froofy$new(1)) Output `class(old)`: "goofy" "R6" `class(new)`: "froofy" "goofy" "R6" `old` is length 3 `new` is length 4 `names(old)`: "clone" "initialize" "x" `names(new)`: "clone" "initialize" "x" "y" `old$y` is absent `new$y` is a double vector (10) Code compare(froofy$new(1), froofy$new(1)$clone()) Output v No differences # Named environments compare by reference Code compare(baseenv(), globalenv()) Output `old` is <env:package:base> `new` is <env:global> Code compare(baseenv(), new.env()) Output `old` is <env:package:base> `new` is <env: 0x********> Code compare(new.env(), baseenv()) Output `old` is <env: 0x********> `new` is <env:package:base> # unnamed arguments compare by value Code e1 <- new.env(parent = emptyenv()) e2 <- new.env(parent = emptyenv()) compare(e1, e2) Output v No differences Code e1$x <- 10 e2$x <- 11 compare(e1, e2) Output `old$x`: 10 `new$x`: 11 Code e2$x <- 10 compare(e1, e2) Output v No differences # compares parent envs Code e1 <- new.env(parent = emptyenv()) e1$x <- 1 e2 <- new.env(parent = emptyenv()) e2$x <- 2 e3 <- new.env(parent = e1) e4 <- new.env(parent = e2) compare(e3, e4) Output `parent.env(old)$x`: 1 `parent.env(new)$x`: 2 # don't get caught in endless loops Code e1 <- new.env(parent = emptyenv()) e2 <- new.env(parent = emptyenv()) e1$x <- 10 e1$y <- e1 e2$x <- 10 e2$y <- e1 compare(e1, e2) Output v No differences Code e2$y <- e2 compare(e1, e2) Output v No differences # only shows paired env different once Code e1 <- new.env(parent = emptyenv()) e2 <- new.env(parent = emptyenv()) e3 <- new.env(parent = emptyenv()) e1$x <- 1 e2$x <- 2 e3$x <- 3 compare(list(e1, e1, e1), list(e2, e2, e3)) Output `old[[1]]$x`: 1 `new[[1]]$x`: 2 `old[[3]]$x`: 1 `new[[3]]$x`: 3 # can compare CHARSXP Code compare(char1, char2) Output `old` is CHARSXP: foo `new` is CHARSXP: bar Code compare(char1, "foo") Output `old` is an internal string `new` is a character vector ('foo') # differences in DOTSXP are ignored Code compare(f(1), f(1, 2)) Output v No differences # comparing language objects gives useful diffs Code compare(quote(a), quote(b)) Output `old` is `a` `new` is `b` Code compare(quote(a + b), quote(b + c)) Output `old`: `a + b` `new`: `b + c` Code x <- y <- quote(foo(1:3)) y[[2]] <- 1:3 compare(x, y) Output `old[[2]]` is a call `new[[2]]` is an integer vector (1, 2, 3) Code compare(expression(1, a, a + b), expression(1, a, a + b)) Output v No differences Code compare(expression(1, a, a + b), expression(1, a, a + c)) Output `old[[3]]`: `a + b` `new[[3]]`: `a + c` # compare_proxy() modifies path Code compare(foo1, foo2) Output `proxy(old)$x`: 1 `proxy(new)$x`: 2
Generated by dwww version 1.15 on Wed Jun 26 02:26:21 CEST 2024.