Add the syntax only for side effect

[renkun-ken]

Consider the following syntax:

x %>>% (~ expr)         # evaluate expr with . = x and return x
x %>>% ((m) ~ expr)     # evaluate expr with m = x and return x

mtcars %>>%
  (~ cat("Number of columns:",ncol(.),"\n")) %>>%
  (mpg) %>>%
  summary

Number of columns: 11 
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  10.40   15.42   19.20   20.09   22.80   33.90 

or

mtcars %>>%
  ((x) ~ cat("Number of columns:",ncol(x),"\n")) %>>%
  (mpg) %>>%
  summary

Number of columns: 11 
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  10.40   15.42   19.20   20.09   22.80   33.90 

where (~ expr) or ((x) ~ expr) indicates that the output of this will be ignored and the input will be returned, thus only for side effect (only one side is stressed in the formula, also looks like expr is evaluated as a side branch)

Note that all syntax in () automatically applies to .() in Pipe, therefore,

Pipe(mtcars)$
  .(~ cat("Number of columns:",ncol(.),"\n"))$
  .(mpg)$
  summary()

Number of columns: 11 
$value : summaryDefault table 
------
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  10.40   15.42   19.20   20.09   22.80   33.90 

[renkun-ken]

A practical case is to make a plot of a linear model before which the partition is set.

mtcars %>>%
  (~ par(mfrow=c(2,2))) %>>%    # only for side effect (par() returns the arg list)
  (lm(mpg ~ cyl + wt, data = .)) %>>%
  plot()

[renkun-ken]

Other examples:

mtcars %>>%
  (~ par(mfrow=c(1,2))) %>>%
  (~ plot(mpg ~ cyl, data = .)) %>>%
  (~ plot(mpg ~ wt, data = .)) %>>%
  (lm(mpg ~ cyl + wt, data = .)) %>>%
  summary() %>>%
  (coefficients)

Pipe(mtcars)$
  .(~ par(mfrow=c(1,2)))$
  .(~ plot(mpg ~ cyl, data = .))$
  .(~ plot(mpg ~ wt, data = .))$
  .(lm(mpg ~ cyl + wt, data = .))$
  summary()$
  .(coefficients)

Do you think it is useful?
Do you think it looks ambiguous even if you know the rule and what it means?

@timelyportfolio @ramnathv @yanlinlin82

[timelyportfolio]

Is the question whether to have this functionality at all or what syntax is best?

I will very clearly demonstrate my ignorance here, but just to make sure I am clear this would accomplish the objective of the magrittr %T>% tee operator? I looked quickly for an equivalent in F#, but could not find any readily available discussions or examples. Are there parallels in F# or other languages where we could borrow the syntax?

Although I use it rarely, it is very nice to have in those rare use cases even beyond logging. I will try to work up the examples where I find it handy and see how this syntax looks. Also, as I work through many examples, see how sticky it is?

I am assuming that deprecation of lambda #31 will be mandatory to prevent confusion.

[renkun-ken]

Yes, it is like magrittr's %T>% operator for side effect and it is not from F# or any other language as far as I know. It helps avoid breaking pipes in some cases where we want some side effects in between, sometimes helpful for me.

magrittr introduces a new operator to do this and more operators to do other things. At early times, I saw only one or two operators in magrittr, and now I see 5 or 6. Instead of introducing new operators, I would like to carefully introduce new syntax that is not confusing and not easily abused.

The feature has been committed to branch 0.4. Would you please try it and give some suggestions? Thanks a lot!

[timelyportfolio]

I updated to the newest 0.4 and will test. In the past, I used most with reference classes (R5).

[renkun-ken]

Thanks! If you think there is better syntax, please let me know. If the feature costs more than the value it brings, it would not go to master.

[timelyportfolio]

Figured I would borrow some code from a package that uses reference classes so I arbitrarily chose lme4. Here is a small snippet where I try to overuse the side effect functionality.

#think this will be useful for reference classes (R5)
install.packages('lme4')
library(lme4)

#borrow from lme4 vignette to test side effects operator
#str(sleepstudy)
#fm1 <- lmer(Reaction ~ Days + (Days | Subject), sleepstudy)
sleepstudy %>>% 
  ( ~ str(.) ) %>>%  #note ( ~ str ) does not print str but still passes through
  #found this in the .Rnw but code is not in final vignette output  
  (~ 
     print(lattice::xyplot(Reaction ~ Days | Subject, ., aspect = "xy",
                    layout = c(9, 2), type = c("g", "p", "r"),
                    index.cond = function(x, y) coef(lm(y ~ x))[2],
                    xlab = "Days of sleep deprivation",
                    ylab = "Average reaction time (ms)",
                    as.table = TRUE))
  ) %>>%
  { lmer( Reaction ~ Days + ( Days | Subject ), . ) } %>>%
  ( ~assign( "fm1", ., envir = .GlobalEnv ) )


#the hard way to accomplish the fm1 above
# formula module
#   parsedFormula <- lFormula(formula = Reaction ~ Days + (Days|Subject),
#                                data = sleepstudy)
# 
#   # objective function module
#   devianceFunction <- do.call(mkLmerDevfun, parsedFormula)
# 
#   # optimization module
#   optimizerOutput <- optimizeLmer(devianceFunction)
# 
#   # output module
#   mkMerMod( rho = environment(devianceFunction),
#                opt = optimizerOutput,
#                reTrms = parsedFormula$reTrms,
#                fr = parsedFormula$fr)

#probably not a likely candidate for pipelining but do it nevertheless
#don't know enough yet about lme4 design to recode yet
sleepstudy %>>%
  ( ~ print("# formula module")) %>>%
  { 
    lFormula (
      formula = Reaction ~ Days + (Days|Subject)
      , data = .
    )
  } %>>%
  ( ~ assign( "parsedFormula", ., envir = .GlobalEnv ) ) %>>%
  ( ~ cat( "test parsedFormula$frame == fm1@frame" ) )%>>%
  ( ~ testthat::is_identical_to(fm1@frame,parsedFormula$fr) ) %>>%
  ( ~ print( "optimization module" ) ) %>>%
  { do.call( mkLmerDevfun, . ) } %>>%
  ( ~ assign( "devianceFunction", ., envir = .GlobalEnv ) ) %>>%
  ( ~ print( "output module" ) ) %>>%
  optimizeLmer %>>%
  {
    mkMerMod (
      rho = environment( devianceFunction )
      ,opt = .
      ,reTrms = parsedFormula$reTrms,
      ,fr = parsedFormula$fr
    )
  }

[timelyportfolio]

Another use similar to logging/documenting that I had not considered would be to test in the pipeline with testthat or rtype.

[renkun-ken]

Here's a pseudo computing example :)

Pipe(1:3)$
    .(~ cat("connect",length(.),"elements with 2 more\n"))$
    .(~ Sys.sleep(1))$
    c(4,5)$
    .(~ cat("calculating mean\n"))$
    .(~ Sys.sleep(1))$
    mean()

[timelyportfolio]

hardest thing for me so far has been ~ inside of () rather than ~(), but the ( ~ ) makes more sense to me. just harder to type for some reason (probably muscle memory).

[renkun-ken]

It's sad that ~(expr) will be parsed to break the evaluation order which does not allow chaining.

> as.list(quote(a %>>% ~(x) %>>% y()))
[[1]]
`%>>%`

[[2]]
a

[[3]]
~(x) %>>% y()

Neither does ~ expr work:

> as.list(quote(a %>>% ~x %>>% y()))
[[1]]
`%>>%`

[[2]]
a

[[3]]
~x %>>% y()

And for (~expr):

> as.list(quote(a %>>% (~x) %>>% y()))
[[1]]
`%>>%`

[[2]]
a %>>% (~x)

[[3]]
y()