Hi, Am 21.10.2016 um 18:10 schrieb William Dunlap:> Are you saying that > f1 <- function(x) log(x) > f2 <- function(x) { log } (x) > should act differently?yes. Or more precisely: I would expect that. "Should" implies, that I want to change something. I just want to understand the behavior (or file a bug, if this would have been one). As I wrote, in e.g. node.js the pendents to the lines that you wrote are treated differently (the first is a function, the latter is a parsing error). Let's use this example instead: x <- 20 f1 <- function(x) { x<-x+1; log(x) } f2 <- function(x) { x<-x+1; log } (x) which act equally. But as the latter is a legal statement, I would read it as f2 <- (function(x) { x<-x+1; log }) (x) thus, I would expect the first to be a function, the latter to be a numeric ( log(20) in this case ).> Using 'return' complicates the matter, because it affects evaluation, > not parsing.But perhaps it illustrates my problem a little better: x <- 20 f1 <- function(x) return(log(x)) f2 <- function(x) { return(log) } (x) f1(10) is a numeric, f2(10) is the log function. Again: as the latter is a legal statement, I would expect: f2 <- (function(x) { x<-x+1; log }) (x) However, regarding the answers I will try to construct the AST regarding the grammar defined in gramm.y of that statement f2 <- function(x) { x<-x+1; log } (x) to understand what the R interpreter really does. Best wishes, Wilm
Am 21.10.2016 um 18:10 schrieb William Dunlap:> > Are you saying thatf1 <- function(x) log(x) f2 <- function(x) { log } (x) should act differently? yes. But that would mean that {log} would act differently than log. I suppose it is a matter of taste, but I say yuck. As for 'return', don't use it if you want readable code. It is like a goto but worse. It is never necessary. Bill Dunlap TIBCO Software wdunlap tibco.com On Fri, Oct 21, 2016 at 10:17 AM, Wilm Schumacher <wilm.schumacher at gmail.com> wrote:> Hi, > > > Am 21.10.2016 um 18:10 schrieb William Dunlap: > >> Are you saying that >> f1 <- function(x) log(x) >> f2 <- function(x) { log } (x) >> should act differently? >> > yes. Or more precisely: I would expect that. "Should" implies, that I want > to change something. I just want to understand the behavior (or file a bug, > if this would have been one). > > As I wrote, in e.g. node.js the pendents to the lines that you wrote are > treated differently (the first is a function, the latter is a parsing > error). > > Let's use this example instead: > x <- 20 > f1 <- function(x) { x<-x+1; log(x) } > f2 <- function(x) { x<-x+1; log } (x) > which act equally. > > But as the latter is a legal statement, I would read it as > f2 <- (function(x) { x<-x+1; log }) (x) > > thus, I would expect the first to be a function, the latter to be a > numeric ( log(20) in this case ). > > > Using 'return' complicates the matter, because it affects evaluation, not >> parsing. >> > > But perhaps it illustrates my problem a little better: > x <- 20 > f1 <- function(x) return(log(x)) > f2 <- function(x) { return(log) } (x) > > f1(10) is a numeric, f2(10) is the log function. Again: as the latter is a > legal statement, I would expect: > f2 <- (function(x) { x<-x+1; log }) (x) > > However, regarding the answers I will try to construct the AST regarding > the grammar defined in gramm.y of that statement > f2 <- function(x) { x<-x+1; log } (x) > to understand what the R interpreter really does. > > Best wishes, > > Wilm > > > > >[[alternative HTML version deleted]]
> On 21 Oct 2016, at 19:17 , Wilm Schumacher <wilm.schumacher at gmail.com> wrote: > > Am 21.10.2016 um 18:10 schrieb William Dunlap: >> Are you saying that >> f1 <- function(x) log(x) >> f2 <- function(x) { log } (x) >> should act differently? > yes. Or more precisely: I would expect that. "Should" implies, that I want to change something. I just want to understand the behavior (or file a bug, if this would have been one).I think Bill and Luke are failing in trying to make you work out the logic for yourself... The point is that { some_computation }(x) is an expression that evaluates some_computation and applies it as a function to the argument x (or fails if not a function). When you define functions, the body can be a single expression, so f <- function(a) { some_computation }(x) is effectively the same as f <- function(a) { { some_computation }(x) } where you seem to be expecting {f <- function(a) { { some_computation } }(x) Got it? -- Peter Dalgaard, Professor, Center for Statistics, Copenhagen Business School Solbjerg Plads 3, 2000 Frederiksberg, Denmark Phone: (+45)38153501 Office: A 4.23 Email: pd.mes at cbs.dk Priv: PDalgd at gmail.com
On Fri, 21 Oct 2016, William Dunlap via R-devel wrote:> Am 21.10.2016 um 18:10 schrieb William Dunlap: >> >> Are you saying that > > f1 <- function(x) log(x) > > f2 <- function(x) { log } (x) > > should act differently? > > yes. > > > But that would mean that {log} would act differently than log. > I suppose it is a matter of taste, but I say yuck. > > As for 'return', don't use it if you want readable code. It is > like a goto but worse. It is never necessary.As a rule I agree, but one case where return is clearer than the alternative is repeat { .... if (...) return(...) } Complicated nested if expressions are also sometimes clearer using return as an early breakout. Best, luke> > > Bill Dunlap > TIBCO Software > wdunlap tibco.com > > On Fri, Oct 21, 2016 at 10:17 AM, Wilm Schumacher <wilm.schumacher at gmail.com >> wrote: > >> Hi, >> >> >> Am 21.10.2016 um 18:10 schrieb William Dunlap: >> >>> Are you saying that >>> f1 <- function(x) log(x) >>> f2 <- function(x) { log } (x) >>> should act differently? >>> >> yes. Or more precisely: I would expect that. "Should" implies, that I want >> to change something. I just want to understand the behavior (or file a bug, >> if this would have been one). >> >> As I wrote, in e.g. node.js the pendents to the lines that you wrote are >> treated differently (the first is a function, the latter is a parsing >> error). >> >> Let's use this example instead: >> x <- 20 >> f1 <- function(x) { x<-x+1; log(x) } >> f2 <- function(x) { x<-x+1; log } (x) >> which act equally. >> >> But as the latter is a legal statement, I would read it as >> f2 <- (function(x) { x<-x+1; log }) (x) >> >> thus, I would expect the first to be a function, the latter to be a >> numeric ( log(20) in this case ). >> >> >> Using 'return' complicates the matter, because it affects evaluation, not >>> parsing. >>> >> >> But perhaps it illustrates my problem a little better: >> x <- 20 >> f1 <- function(x) return(log(x)) >> f2 <- function(x) { return(log) } (x) >> >> f1(10) is a numeric, f2(10) is the log function. Again: as the latter is a >> legal statement, I would expect: >> f2 <- (function(x) { x<-x+1; log }) (x) >> >> However, regarding the answers I will try to construct the AST regarding >> the grammar defined in gramm.y of that statement >> f2 <- function(x) { x<-x+1; log } (x) >> to understand what the R interpreter really does. >> >> Best wishes, >> >> Wilm >> >> >> >> >> > > [[alternative HTML version deleted]] > > ______________________________________________ > R-devel at r-project.org mailing list > https://stat.ethz.ch/mailman/listinfo/r-devel >-- Luke Tierney Ralph E. Wareham Professor of Mathematical Sciences University of Iowa Phone: 319-335-3386 Department of Statistics and Fax: 319-335-3017 Actuarial Science 241 Schaeffer Hall email: luke-tierney at uiowa.edu Iowa City, IA 52242 WWW: http://www.stat.uiowa.edu