Type stable [<- for base classes

[hadley]

i.e. ensures that the type of x does not change.

Needed for tidyverse/purrr#579

[krlmlr]

I don't see how to do this for [<-, but we could change vec_slice<-() . Currently:

x <- 2:6
vctrs::vec_slice(x, 2:4) <- "foo"
x
#> [1] "2"   "foo" "foo" "foo" "6"

^{Created on 2019-02-10 by the reprex package (v0.2.1.9000)}

[krlmlr]

I'm not sure casting is the right operation here:

library(vctrs)
x <- 2:6
vctrs::vec_slice(x, 2:4) <- vec_cast("3", vec_type(x))
x
#> [1] 2 3 3 3 6

^{Created on 2019-02-27 by the reprex package (v0.2.1.9000)}

I'd say we still throw an error here. We'd also throw an error if vec_type2(x, value) return anything different than vec_type(x). (Subset assignment never changes the data type.?) Do we need a new vec_coerce() ?

[hadley]

Alternatively we just do vec_assert(). We could always relax it later if that turns out to be too painful.

[hadley]

No, that's going to be too strict — it's going to make it painful to change (e.g.) dates or factors.

[lionel-]

Distinguishing coercion and casting we have:

vec_coerce <- function(x, to) {
  vec_cast(x, vec_type2(x, to))
}

x <- 1:6
i <- 2:4

y <- "10"
vec_slice(x, i) <- vec_coerce(y, x)
#> Error: No common type for <character> and <integer>.

y <- 10
vec_slice(x, i) <- vec_coerce(y, x)

This means the type of x might change:

typeof(x)
#> [1] "double"

Which we can't really avoid for practical purposes. But with sane coercion implementations, the result should be in the same genericity domain (here, numeric) or fail, instead of falling back to character as in base R.

[krlmlr]

I don't think [<- should change the underlying type. Going with the cast for now, we can revisit later.

[lionel-]

I'm working on casting @krlmlr.

[lionel-]

@hadley suggested a third option: casting value to the type of x, but only if x and value have a common type. Maybe it's safer to just vec_assert() for now, until we figure out the correct way.

[krlmlr]

We also should look at the interplay between vec_slice<-() and [<-(). Currently, the former calls the latter.

What if we made vec_slice<-() very strict (i.e., value must be the same type), and [<-() closer to the behavior of base R (casting to a common subtype)?

[lionel-]

I'm wondering whether we should call vec_slice() from [. This way we consistently preserve attributes.

[lionel-]

I.e. I think it's better for vec_slice() / [ and their assign variants to have consistent behaviour.

[krlmlr]

Consistent, yes, but vec_slice() still can be stricter than [? (Basically, because we can't influence the behavior of [ for types we don't control?)

[lionel-]

I think our types should have strict [ just like tibble implements a stricter interface than data.frame.