Using the pipe, |>, syntax with "names<-"

This post is likely pretty useless;  it is motivated by a recent post
from "Val" that was elegantly answered using Tidyverse constructs, but
I wondered how to do it using base R only. Along the way, I ran into
the following question to which I think my answer (below) is pretty
awful. I would be interested in more elegant base R approaches. So...

z <- data.frame(a = 1:3, b = letters[1:3])

z

  a h
1 1 a
2 2 b
3 3 c

Suppose I want to change the name of the second column of z from 'b'
to 'foo' . This is very easy using nested function syntax by:

names(z)[2] <- "foo"

z

  a foo
1 1   a
2 2   b
3 3   c

Now suppose I wanted to do this using |> syntax, along the lines of:

z |> names()[2] <- "foo"  ## throws an error

Slightly fancier is:

z |> (\(x)names(x)[2] <- "b")()
## does nothing, but does not throw an error.

However, the following, which resulted from a more careful read of
?names works (after changing the name of the second column back to "b"
of course):

z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

  a foo
1 1   a
2 2   b
3 3   c

This qualifies to me as "pretty awful." I'm sure there are better ways
to do this using pipe syntax, so I would appreciate any better
approaches.

Best,
Bert

z

Nope, I still got it wrong: None of my approaches work.  :(

So my query remains: how to do it via piping with |> ?

Bert


On Sat, Jul 20, 2024 at 1:06?PM Bert Gunter <bgunter.4567 at gmail.com> wrote:

This post is likely pretty useless;  it is motivated by a recent post
from "Val" that was elegantly answered using Tidyverse constructs, but
I wondered how to do it using base R only. Along the way, I ran into
the following question to which I think my answer (below) is pretty
awful. I would be interested in more elegant base R approaches. So...

z <- data.frame(a = 1:3, b = letters[1:3])

z

  a h
1 1 a
2 2 b
3 3 c

Suppose I want to change the name of the second column of z from 'b'
to 'foo' . This is very easy using nested function syntax by:

names(z)[2] <- "foo"

z

  a foo
1 1   a
2 2   b
3 3   c

Now suppose I wanted to do this using |> syntax, along the lines of:

z |> names()[2] <- "foo"  ## throws an error

Slightly fancier is:

z |> (\(x)names(x)[2] <- "b")()
## does nothing, but does not throw an error.

However, the following, which resulted from a more careful read of
?names works (after changing the name of the second column back to "b"
of course):

z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

  a foo
1 1   a
2 2   b
3 3   c

This qualifies to me as "pretty awful." I'm sure there are better ways
to do this using pipe syntax, so I would appreciate any better
approaches.

Best,
Bert

With further fooling around, I realized that explicitly assigning my
last "solution" 'works'; i.e.

names(z)[2] <- "foo"

can be piped as:

  z <- z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

   a foo
1 1   a
2 2   b
3 3   c

This is even awfuller than before. So my query still stands.

-- Bert

On Sat, Jul 20, 2024 at 1:14?PM Bert Gunter <bgunter.4567 at gmail.com> wrote:

Nope, I still got it wrong: None of my approaches work.  :(

So my query remains: how to do it via piping with |> ?

Bert


On Sat, Jul 20, 2024 at 1:06?PM Bert Gunter <bgunter.4567 at gmail.com> wrote:

This post is likely pretty useless;  it is motivated by a recent post
from "Val" that was elegantly answered using Tidyverse constructs, but
I wondered how to do it using base R only. Along the way, I ran into
the following question to which I think my answer (below) is pretty
awful. I would be interested in more elegant base R approaches. So...

z <- data.frame(a = 1:3, b = letters[1:3])

z

   a h
1 1 a
2 2 b
3 3 c

Suppose I want to change the name of the second column of z from 'b'
to 'foo' . This is very easy using nested function syntax by:

names(z)[2] <- "foo"

z

   a foo
1 1   a
2 2   b
3 3   c

Now suppose I wanted to do this using |> syntax, along the lines of:

z |> names()[2] <- "foo"  ## throws an error

Slightly fancier is:

z |> (\(x)names(x)[2] <- "b")()
## does nothing, but does not throw an error.

However, the following, which resulted from a more careful read of
?names works (after changing the name of the second column back to "b"
of course):

z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

   a foo
1 1   a
2 2   b
3 3   c

This qualifies to me as "pretty awful." I'm sure there are better ways
to do this using pipe syntax, so I would appreciate any better
approaches.

Best,
Bert

With further fooling around, I realized that explicitly assigning my
last "solution" 'works'; i.e.

names(z)[2] <- "foo"

can be piped as:

  z <- z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

   a foo
1 1   a
2 2   b
3 3   c

This is even awfuller than before. So my query still stands.

-- Bert

On Sat, Jul 20, 2024 at 1:14?PM Bert Gunter <bgunter.4567 at gmail.com> wrote:

Nope, I still got it wrong: None of my approaches work.  :(

So my query remains: how to do it via piping with |> ?

Bert


On Sat, Jul 20, 2024 at 1:06?PM Bert Gunter <bgunter.4567 at gmail.com> wrote:

This post is likely pretty useless;  it is motivated by a recent post
from "Val" that was elegantly answered using Tidyverse constructs, but
I wondered how to do it using base R only. Along the way, I ran into
the following question to which I think my answer (below) is pretty
awful. I would be interested in more elegant base R approaches. So...

z <- data.frame(a = 1:3, b = letters[1:3])

z

   a h
1 1 a
2 2 b
3 3 c

Suppose I want to change the name of the second column of z from 'b'
to 'foo' . This is very easy using nested function syntax by:

names(z)[2] <- "foo"

z

   a foo
1 1   a
2 2   b
3 3   c

Now suppose I wanted to do this using |> syntax, along the lines of:

z |> names()[2] <- "foo"  ## throws an error

Slightly fancier is:

z |> (\(x)names(x)[2] <- "b")()
## does nothing, but does not throw an error.

However, the following, which resulted from a more careful read of
?names works (after changing the name of the second column back to "b"
of course):

z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

   a foo
1 1   a
2 2   b
3 3   c

This qualifies to me as "pretty awful." I'm sure there are better ways
to do this using pipe syntax, so I would appreciate any better
approaches.

Best,
Bert

With further fooling around, I realized that explicitly assigning my
last "solution" 'works'; i.e.

names(z)[2] <- "foo"

can be piped as:

 z <- z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

  a foo
1 1   a
2 2   b
3 3   c

This is even awfuller than before. So my query still stands.

-- Bert

On Sat, Jul 20, 2024 at 1:14?PM Bert Gunter <bgunter.4567 at gmail.com> wrote:

Nope, I still got it wrong: None of my approaches work.  :(

So my query remains: how to do it via piping with |> ?

Bert


On Sat, Jul 20, 2024 at 1:06?PM Bert Gunter <bgunter.4567 at gmail.com> wrote:

This post is likely pretty useless;  it is motivated by a recent post
from "Val" that was elegantly answered using Tidyverse constructs, but
I wondered how to do it using base R only. Along the way, I ran into
the following question to which I think my answer (below) is pretty
awful. I would be interested in more elegant base R approaches. So...

z <- data.frame(a = 1:3, b = letters[1:3])

z

  a h
1 1 a
2 2 b
3 3 c

Suppose I want to change the name of the second column of z from 'b'
to 'foo' . This is very easy using nested function syntax by:

names(z)[2] <- "foo"

z

  a foo
1 1   a
2 2   b
3 3   c

Now suppose I wanted to do this using |> syntax, along the lines of:

z |> names()[2] <- "foo"  ## throws an error

Slightly fancier is:

z |> (\(x)names(x)[2] <- "b")()
## does nothing, but does not throw an error.

However, the following, which resulted from a more careful read of
?names works (after changing the name of the second column back to "b"
of course):

z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

  a foo
1 1   a
2 2   b
3 3   c

This qualifies to me as "pretty awful." I'm sure there are better ways
to do this using pipe syntax, so I would appreciate any better
approaches.

Best,
Bert

`names<-`

`names<-`(z, c("one","two"))

z

z <-

z

z

Nope, I still got it wrong: None of my approaches work.  :(

So my query remains: how to do it via piping with |> ?

Bert


On Sat, Jul 20, 2024 at 1:06?PM Bert Gunter <bgunter.4567 at gmail.com> wrote:

This post is likely pretty useless;  it is motivated by a recent post
from "Val" that was elegantly answered using Tidyverse constructs, but
I wondered how to do it using base R only. Along the way, I ran into
the following question to which I think my answer (below) is pretty
awful. I would be interested in more elegant base R approaches. So...

z <- data.frame(a = 1:3, b = letters[1:3])

z

  a h
1 1 a
2 2 b
3 3 c

Suppose I want to change the name of the second column of z from 'b'
to 'foo' . This is very easy using nested function syntax by:

names(z)[2] <- "foo"

z

  a foo
1 1   a
2 2   b
3 3   c

Now suppose I wanted to do this using |> syntax, along the lines of:

z |> names()[2] <- "foo"  ## throws an error

Slightly fancier is:

z |> (\(x)names(x)[2] <- "b")()
## does nothing, but does not throw an error.

However, the following, which resulted from a more careful read of
?names works (after changing the name of the second column back to "b"
of course):

z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

  a foo
1 1   a
2 2   b
3 3   c

This qualifies to me as "pretty awful." I'm sure there are better ways
to do this using pipe syntax, so I would appreciate any better
approaches.

Best,
Bert

It should be written more like this:

```R
z <- data.frame(a = 1:3, b = letters[1:3])
z |> names() |> _[2] <- "foo"
z
```

Regards,
    Iris

On Sat, Jul 20, 2024 at 4:47?PM Bert Gunter <bgunter.4567 at gmail.com> wrote:

With further fooling around, I realized that explicitly assigning my
last "solution" 'works'; i.e.

names(z)[2] <- "foo"

can be piped as:

 z <- z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

  a foo
1 1   a
2 2   b
3 3   c

This is even awfuller than before. So my query still stands.

-- Bert

On Sat, Jul 20, 2024 at 1:14?PM Bert Gunter <bgunter.4567 at gmail.com> wrote:

Nope, I still got it wrong: None of my approaches work.  :(

So my query remains: how to do it via piping with |> ?

Bert


On Sat, Jul 20, 2024 at 1:06?PM Bert Gunter <bgunter.4567 at gmail.com> wrote:

This post is likely pretty useless;  it is motivated by a recent post
from "Val" that was elegantly answered using Tidyverse constructs, but
I wondered how to do it using base R only. Along the way, I ran into
the following question to which I think my answer (below) is pretty
awful. I would be interested in more elegant base R approaches. So...

z <- data.frame(a = 1:3, b = letters[1:3])

z

  a h
1 1 a
2 2 b
3 3 c

Suppose I want to change the name of the second column of z from 'b'
to 'foo' . This is very easy using nested function syntax by:

names(z)[2] <- "foo"

z

  a foo
1 1   a
2 2   b
3 3   c

Now suppose I wanted to do this using |> syntax, along the lines of:

z |> names()[2] <- "foo"  ## throws an error

Slightly fancier is:

z |> (\(x)names(x)[2] <- "b")()
## does nothing, but does not throw an error.

However, the following, which resulted from a more careful read of
?names works (after changing the name of the second column back to "b"
of course):

z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

  a foo
1 1   a
2 2   b
3 3   c

This qualifies to me as "pretty awful." I'm sure there are better ways
to do this using pipe syntax, so I would appreciate any better
approaches.

Best,
Bert

z <- data.frame(a = 1:3, b = letters[1:3])
z |> names() |> _[2] <- "foo"
z

On Jul 20, 2024, at 18:21, Duncan Murdoch <murdoch.duncan at gmail.com> wrote:

On 2024-07-20 6:02 p.m., Iris Simmons wrote:

z <- data.frame(a = 1:3, b = letters[1:3])
z |> names() |> _[2] <- "foo"
z

That's a great suggestion!

Duncan Murdoch

I think Iris's solution should be added to the help file: ?|>
there are no examples there now that show assignment or replacement using the "_"

On Jul 20, 2024, at 18:21, Duncan Murdoch <murdoch.duncan at gmail.com> wrote:

On 2024-07-20 6:02 p.m., Iris Simmons wrote:

z <- data.frame(a = 1:3, b = letters[1:3])
z |> names() |> _[2] <- "foo"
z

That's a great suggestion!

Duncan Murdoch

z <- data.frame(a = 1:3, b = letters[1:3])
z |> names() |> elt(2)

z |> names() |> elt(2) <- "foo"
z

data.frame(a = 1:3, b = letters[1:3]) |> names() |> _[2] <- "bar"

I second Rich's excellent suggestion.

As with all elegant solutions, Iris's clicked on the wee light bulb in
my brain, and I realized that a slightly more verbose, but perhaps
more enlightening, alternative may be:

z |>  attr("names") |> _[2] <- "foo"

However, I would add this as an example *only with* Iris's solution.
Hers should be shown whether or not the above is.

Cheers,
Bert

On Sat, Jul 20, 2024 at 3:35?PM Richard M. Heiberger <rmh at temple.edu>
wrote:

I think Iris's solution should be added to the help file: ?|>
there are no examples there now that show assignment or replacement

using the "_"

On Jul 20, 2024, at 18:21, Duncan Murdoch <murdoch.duncan at gmail.com>

wrote:

On 2024-07-20 6:02 p.m., Iris Simmons wrote:

z <- data.frame(a = 1:3, b = letters[1:3])
z |> names() |> _[2] <- "foo"
z

That's a great suggestion!

Duncan Murdoch

The main challenge in Bert's original problem is that `[` and `[<-` cannot
be called in a pipeline. The obvious solution is to define named versions,
e.g.:

elt <- `[`
`elt<-` <- `[<-`

Then,

z <- data.frame(a = 1:3, b = letters[1:3])
z |> names() |> elt(2)

[1] "b"

z |> names() |> elt(2) <- "foo"
z

 a foo
1 1   a
2 2   b
3 3   c

You could actually also do (using a similar function already defined in
methods)

z |> names() |> el(2) <- "bar"

Iris's _ trick is of course a nice alternative; and this example in ?pipeOp
already covers it:

# using the placeholder as the head of an extraction chain:
mtcars |> subset(cyl == 4) |> lm(formula = mpg ~ disp) |> _$coef[[2]]

While the replacement question is a nice exercise, I am not sure about the
value of emphasizing that you can use pipes to do complex assignments.
Doesn't that defeat the whole purpose of piping? For one thing, it will
necessarily terminate the pipe. Also, it will not work if the starting
value is not a variable. E.g.,

data.frame(a = 1:3, b = letters[1:3]) |> names() |> _[2] <- "bar"

Error in names(data.frame(a = 1:3, b = letters[1:3]))[2] <- "bar" :
 target of assignment expands to non-language object

Duncan's rename() approach, which will just change the column name and
return the modified object, seems more useful as part of a pipeline.

Best,
-Deepayan

On Sun, 21 Jul 2024 at 04:46, Bert Gunter <bgunter.4567 at gmail.com> wrote:

I second Rich's excellent suggestion.

As with all elegant solutions, Iris's clicked on the wee light bulb in
my brain, and I realized that a slightly more verbose, but perhaps
more enlightening, alternative may be:

z |>  attr("names") |> _[2] <- "foo"

However, I would add this as an example *only with* Iris's solution.
Hers should be shown whether or not the above is.

Cheers,
Bert

On Sat, Jul 20, 2024 at 3:35?PM Richard M. Heiberger <rmh at temple.edu>
wrote:

I think Iris's solution should be added to the help file: ?|>
there are no examples there now that show assignment or replacement

using the "_"

On Jul 20, 2024, at 18:21, Duncan Murdoch <murdoch.duncan at gmail.com>

wrote:

On 2024-07-20 6:02 p.m., Iris Simmons wrote:

z <- data.frame(a = 1:3, b = letters[1:3])
z |> names() |> _[2] <- "foo"
z

That's a great suggestion!

Duncan Murdoch

[[alternative HTML version deleted]]

z <- data.frame(a = 1:3, b = letters[1:3])
z |> names() |> elt(2)

z |> names() |> elt(2) <- "foo"
z

data.frame(a = 1:3, b = letters[1:3]) |> names() |> _[2] <- "bar"

I second Rich's excellent suggestion.

As with all elegant solutions, Iris's clicked on the wee light bulb in
my brain, and I realized that a slightly more verbose, but perhaps
more enlightening, alternative may be:

z |>  attr("names") |> _[2] <- "foo"

However, I would add this as an example *only with* Iris's solution.
Hers should be shown whether or not the above is.

Cheers,
Bert

On Sat, Jul 20, 2024 at 3:35?PM Richard M. Heiberger <rmh at temple.edu>
wrote:

I think Iris's solution should be added to the help file: ?|>
there are no examples there now that show assignment or replacement

using the "_"

On Jul 20, 2024, at 18:21, Duncan Murdoch <murdoch.duncan at gmail.com>

wrote:

On 2024-07-20 6:02 p.m., Iris Simmons wrote:

z <- data.frame(a = 1:3, b = letters[1:3])
z |> names() |> _[2] <- "foo"
z

That's a great suggestion!

Duncan Murdoch

This post is likely pretty useless;  it is motivated by a recent post
from "Val" that was elegantly answered using Tidyverse constructs, but
I wondered how to do it using base R only. Along the way, I ran into
the following question to which I think my answer (below) is pretty
awful. I would be interested in more elegant base R approaches. So...

z <- data.frame(a = 1:3, b = letters[1:3])

z

  a h
1 1 a
2 2 b
3 3 c

Suppose I want to change the name of the second column of z from 'b'
to 'foo' . This is very easy using nested function syntax by:

names(z)[2] <- "foo"

z

  a foo
1 1   a
2 2   b
3 3   c

Now suppose I wanted to do this using |> syntax, along the lines of:

z |> names()[2] <- "foo"  ## throws an error

Slightly fancier is:

z |> (\(x)names(x)[2] <- "b")()
## does nothing, but does not throw an error.

However, the following, which resulted from a more careful read of
?names works (after changing the name of the second column back to "b"
of course):

z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

  a foo
1 1   a
2 2   b
3 3   c

This qualifies to me as "pretty awful." I'm sure there are better ways
to do this using pipe syntax, so I would appreciate any better
approaches.

Best,
Bert

This
- is non-destructive (does not change z)
- passes the renamed z onto further pipe legs
- does not use \(x)...

It works by boxing z, operating on the boxed version and then unboxing it.

  z <- data.frame(a = 1:3, b = letters[1:3])
  z |> list(x = _) |> within(names(x)[2] <- "foo") |> _$x
  ##   a foo
  ## 1 1   a
  ## 2 2   b
  ## 3 3   c

On Sat, Jul 20, 2024 at 4:07?PM Bert Gunter <bgunter.4567 at gmail.com> wrote:

This post is likely pretty useless;  it is motivated by a recent post
from "Val" that was elegantly answered using Tidyverse constructs, but
I wondered how to do it using base R only. Along the way, I ran into
the following question to which I think my answer (below) is pretty
awful. I would be interested in more elegant base R approaches. So...

z <- data.frame(a = 1:3, b = letters[1:3])

z

  a h
1 1 a
2 2 b
3 3 c

Suppose I want to change the name of the second column of z from 'b'
to 'foo' . This is very easy using nested function syntax by:

names(z)[2] <- "foo"

z

  a foo
1 1   a
2 2   b
3 3   c

Now suppose I wanted to do this using |> syntax, along the lines of:

z |> names()[2] <- "foo"  ## throws an error

Slightly fancier is:

z |> (\(x)names(x)[2] <- "b")()
## does nothing, but does not throw an error.

However, the following, which resulted from a more careful read of
?names works (after changing the name of the second column back to "b"
of course):

z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

  a foo
1 1   a
2 2   b
3 3   c

This qualifies to me as "pretty awful." I'm sure there are better ways
to do this using pipe syntax, so I would appreciate any better
approaches.

Best,
Bert

--
Statistics & Software Consulting
GKX Group, GKX Associates Inc.
tel: 1-877-GKX-GROUP
email: ggrothendieck at gmail.com

Wow!
Yes, this is very clever -- way too clever for me -- and meets my
criteria for a solution.

I think it's also another piece of evidence of why piping in base R is
not suited for complex/nested assignments, as discussed in Deepayan's
response.

Maybe someone could offer a better Tidydata piping solution just for
completeness?

Best,
Bert

On Sun, Jul 21, 2024 at 7:48?AM Gabor Grothendieck
<ggrothendieck at gmail.com> wrote:

This
- is non-destructive (does not change z)
- passes the renamed z onto further pipe legs
- does not use \(x)...

It works by boxing z, operating on the boxed version and then unboxing it.

  z <- data.frame(a = 1:3, b = letters[1:3])
  z |> list(x = _) |> within(names(x)[2] <- "foo") |> _$x
  ##   a foo
  ## 1 1   a
  ## 2 2   b
  ## 3 3   c

On Sat, Jul 20, 2024 at 4:07?PM Bert Gunter <bgunter.4567 at gmail.com> wrote:

This post is likely pretty useless;  it is motivated by a recent post
from "Val" that was elegantly answered using Tidyverse constructs, but
I wondered how to do it using base R only. Along the way, I ran into
the following question to which I think my answer (below) is pretty
awful. I would be interested in more elegant base R approaches. So...

z <- data.frame(a = 1:3, b = letters[1:3])

z

  a h
1 1 a
2 2 b
3 3 c

Suppose I want to change the name of the second column of z from 'b'
to 'foo' . This is very easy using nested function syntax by:

names(z)[2] <- "foo"

z

  a foo
1 1   a
2 2   b
3 3   c

Now suppose I wanted to do this using |> syntax, along the lines of:

z |> names()[2] <- "foo"  ## throws an error

Slightly fancier is:

z |> (\(x)names(x)[2] <- "b")()
## does nothing, but does not throw an error.

However, the following, which resulted from a more careful read of
?names works (after changing the name of the second column back to "b"
of course):

z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

  a foo
1 1   a
2 2   b
3 3   c

This qualifies to me as "pretty awful." I'm sure there are better ways
to do this using pipe syntax, so I would appreciate any better
approaches.

Best,
Bert

--
Statistics & Software Consulting
GKX Group, GKX Associates Inc.
tel: 1-877-GKX-GROUP
email: ggrothendieck at gmail.com

Wow!
Yes, this is very clever -- way too clever for me -- and meets my
criteria for a solution.

I think it's also another piece of evidence of why piping in base R is
not suited for complex/nested assignments, as discussed in Deepayan's
response.

Maybe someone could offer a better Tidydata piping solution just for
completeness?

Best,
Bert

On Sun, Jul 21, 2024 at 7:48?AM Gabor Grothendieck
<ggrothendieck at gmail.com> wrote:

This
- is non-destructive (does not change z)
- passes the renamed z onto further pipe legs
- does not use \(x)...

It works by boxing z, operating on the boxed version and then unboxing

it.

  z <- data.frame(a = 1:3, b = letters[1:3])
  z |> list(x = _) |> within(names(x)[2] <- "foo") |> _$x
  ##   a foo
  ## 1 1   a
  ## 2 2   b
  ## 3 3   c

On Sat, Jul 20, 2024 at 4:07?PM Bert Gunter <bgunter.4567 at gmail.com>

wrote:

This post is likely pretty useless;  it is motivated by a recent post
from "Val" that was elegantly answered using Tidyverse constructs, but
I wondered how to do it using base R only. Along the way, I ran into
the following question to which I think my answer (below) is pretty
awful. I would be interested in more elegant base R approaches. So...

z <- data.frame(a = 1:3, b = letters[1:3])

z

  a h
1 1 a
2 2 b
3 3 c

Suppose I want to change the name of the second column of z from 'b'
to 'foo' . This is very easy using nested function syntax by:

names(z)[2] <- "foo"

z

  a foo
1 1   a
2 2   b
3 3   c

Now suppose I wanted to do this using |> syntax, along the lines of:

z |> names()[2] <- "foo"  ## throws an error

Slightly fancier is:

z |> (\(x)names(x)[2] <- "b")()
## does nothing, but does not throw an error.

However, the following, which resulted from a more careful read of
?names works (after changing the name of the second column back to "b"
of course):

z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

  a foo
1 1   a
2 2   b
3 3   c

This qualifies to me as "pretty awful." I'm sure there are better ways
to do this using pipe syntax, so I would appreciate any better
approaches.

Best,
Bert

hmmm...
But note that you still used the nested assignment, names()[2] <-
"foo", to circumvent R's pipe limitations, which is exactly what
Iris's solution avoids. So I think I was overawed by your cleverness
;-)

Best,
Bert


On Sun, Jul 21, 2024 at 8:01?AM Bert Gunter <bgunter.4567 at gmail.com> wrote:

Wow!
Yes, this is very clever -- way too clever for me -- and meets my
criteria for a solution.

I think it's also another piece of evidence of why piping in base R is
not suited for complex/nested assignments, as discussed in Deepayan's
response.

Maybe someone could offer a better Tidydata piping solution just for
completeness?

Best,
Bert

On Sun, Jul 21, 2024 at 7:48?AM Gabor Grothendieck
<ggrothendieck at gmail.com> wrote:

This
- is non-destructive (does not change z)
- passes the renamed z onto further pipe legs
- does not use \(x)...

It works by boxing z, operating on the boxed version and then unboxing it.

  z <- data.frame(a = 1:3, b = letters[1:3])
  z |> list(x = _) |> within(names(x)[2] <- "foo") |> _$x
  ##   a foo
  ## 1 1   a
  ## 2 2   b
  ## 3 3   c

On Sat, Jul 20, 2024 at 4:07?PM Bert Gunter <bgunter.4567 at gmail.com> wrote:

This post is likely pretty useless;  it is motivated by a recent post
from "Val" that was elegantly answered using Tidyverse constructs, but
I wondered how to do it using base R only. Along the way, I ran into
the following question to which I think my answer (below) is pretty
awful. I would be interested in more elegant base R approaches. So...

z <- data.frame(a = 1:3, b = letters[1:3])

z

  a h
1 1 a
2 2 b
3 3 c

Suppose I want to change the name of the second column of z from 'b'
to 'foo' . This is very easy using nested function syntax by:

names(z)[2] <- "foo"

z

  a foo
1 1   a
2 2   b
3 3   c

Now suppose I wanted to do this using |> syntax, along the lines of:

z |> names()[2] <- "foo"  ## throws an error

Slightly fancier is:

z |> (\(x)names(x)[2] <- "b")()
## does nothing, but does not throw an error.

However, the following, which resulted from a more careful read of
?names works (after changing the name of the second column back to "b"
of course):

z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

  a foo
1 1   a
2 2   b
3 3   c

This qualifies to me as "pretty awful." I'm sure there are better ways
to do this using pipe syntax, so I would appreciate any better
approaches.

Best,
Bert

--
Statistics & Software Consulting
GKX Group, GKX Associates Inc.
tel: 1-877-GKX-GROUP
email: ggrothendieck at gmail.com

The tidy solution is rename

literally:

z |> rename(foo = 2)

Or you could do it with other functions

z |> select ( 1, foo = 2)

Or

z |> mutate( foo = 2 ) |> # untested (always worry that makes the whole column 2)
select (-2)

But that's akin to

z$foo <- z[2]
z[2] <- null


On Sun, 21 Jul 2024, 16:01 Bert Gunter, <bgunter.4567 at gmail.com> wrote:

Wow!
Yes, this is very clever -- way too clever for me -- and meets my
criteria for a solution.

I think it's also another piece of evidence of why piping in base R is
not suited for complex/nested assignments, as discussed in Deepayan's
response.

Maybe someone could offer a better Tidydata piping solution just for
completeness?

Best,
Bert

On Sun, Jul 21, 2024 at 7:48?AM Gabor Grothendieck
<ggrothendieck at gmail.com> wrote:

This
- is non-destructive (does not change z)
- passes the renamed z onto further pipe legs
- does not use \(x)...

It works by boxing z, operating on the boxed version and then unboxing it.

  z <- data.frame(a = 1:3, b = letters[1:3])
  z |> list(x = _) |> within(names(x)[2] <- "foo") |> _$x
  ##   a foo
  ## 1 1   a
  ## 2 2   b
  ## 3 3   c

On Sat, Jul 20, 2024 at 4:07?PM Bert Gunter <bgunter.4567 at gmail.com> wrote:

This post is likely pretty useless;  it is motivated by a recent post
from "Val" that was elegantly answered using Tidyverse constructs, but
I wondered how to do it using base R only. Along the way, I ran into
the following question to which I think my answer (below) is pretty
awful. I would be interested in more elegant base R approaches. So...

z <- data.frame(a = 1:3, b = letters[1:3])

z

  a h
1 1 a
2 2 b
3 3 c

Suppose I want to change the name of the second column of z from 'b'
to 'foo' . This is very easy using nested function syntax by:

names(z)[2] <- "foo"

z

  a foo
1 1   a
2 2   b
3 3   c

Now suppose I wanted to do this using |> syntax, along the lines of:

z |> names()[2] <- "foo"  ## throws an error

Slightly fancier is:

z |> (\(x)names(x)[2] <- "b")()
## does nothing, but does not throw an error.

However, the following, which resulted from a more careful read of
?names works (after changing the name of the second column back to "b"
of course):

z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

  a foo
1 1   a
2 2   b
3 3   c

This qualifies to me as "pretty awful." I'm sure there are better ways
to do this using pipe syntax, so I would appreciate any better
approaches.

Best,
Bert

--
Statistics & Software Consulting
GKX Group, GKX Associates Inc.
tel: 1-877-GKX-GROUP
email: ggrothendieck at gmail.com

If you object to names(x)[2]<- ... then use replace:

  z |> list(x = _) |> within(replace(names(x), 2, "foo")) |> _$x

On Sun, Jul 21, 2024 at 11:10?AM Bert Gunter <bgunter.4567 at gmail.com> wrote:

hmmm...
But note that you still used the nested assignment, names()[2] <-
"foo", to circumvent R's pipe limitations, which is exactly what
Iris's solution avoids. So I think I was overawed by your cleverness
;-)

Best,
Bert


On Sun, Jul 21, 2024 at 8:01?AM Bert Gunter <bgunter.4567 at gmail.com> wrote:

Wow!
Yes, this is very clever -- way too clever for me -- and meets my
criteria for a solution.

I think it's also another piece of evidence of why piping in base R is
not suited for complex/nested assignments, as discussed in Deepayan's
response.

Maybe someone could offer a better Tidydata piping solution just for
completeness?

Best,
Bert

On Sun, Jul 21, 2024 at 7:48?AM Gabor Grothendieck
<ggrothendieck at gmail.com> wrote:

This
- is non-destructive (does not change z)
- passes the renamed z onto further pipe legs
- does not use \(x)...

It works by boxing z, operating on the boxed version and then unboxing it.

  z <- data.frame(a = 1:3, b = letters[1:3])
  z |> list(x = _) |> within(names(x)[2] <- "foo") |> _$x
  ##   a foo
  ## 1 1   a
  ## 2 2   b
  ## 3 3   c

On Sat, Jul 20, 2024 at 4:07?PM Bert Gunter <bgunter.4567 at gmail.com> wrote:

This post is likely pretty useless;  it is motivated by a recent post
from "Val" that was elegantly answered using Tidyverse constructs, but
I wondered how to do it using base R only. Along the way, I ran into
the following question to which I think my answer (below) is pretty
awful. I would be interested in more elegant base R approaches. So...

z <- data.frame(a = 1:3, b = letters[1:3])

z

  a h
1 1 a
2 2 b
3 3 c

Suppose I want to change the name of the second column of z from 'b'
to 'foo' . This is very easy using nested function syntax by:

names(z)[2] <- "foo"

z

  a foo
1 1   a
2 2   b
3 3   c

Now suppose I wanted to do this using |> syntax, along the lines of:

z |> names()[2] <- "foo"  ## throws an error

Slightly fancier is:

z |> (\(x)names(x)[2] <- "b")()
## does nothing, but does not throw an error.

However, the following, which resulted from a more careful read of
?names works (after changing the name of the second column back to "b"
of course):

z |>(\(x) "names<-"(x,value = "[<-"(names(x),2,'foo')))()

z

  a foo
1 1   a
2 2   b
3 3   c

This qualifies to me as "pretty awful." I'm sure there are better ways
to do this using pipe syntax, so I would appreciate any better
approaches.

Best,
Bert

--
Statistics & Software Consulting
GKX Group, GKX Associates Inc.
tel: 1-877-GKX-GROUP
email: ggrothendieck at gmail.com

--
Statistics & Software Consulting
GKX Group, GKX Associates Inc.
tel: 1-877-GKX-GROUP
email: ggrothendieck at gmail.com