similar to: Getting ... without evaluating it?

This may have been asked before, but is there an elegant way to check whether an variable/argument passed to a function is a "parse tree" for an (unevaluated) expression or not, *without* evaluating it if not? Currently, I do various rather ad hoc eval()+substitute() tricks for this that most likely only work under certain circumstances. Ideally, I'm looking for a isParseTree()

Hi, I'm trying to get ...as a list of unevaluated arguments, ie. substitute(list(...)) gives me an unevaluated list of the arguments, but I want a list of the unevaluated arguments. My attempts so far: (function(...) substitute(...))(a=1, b=a) # Only returns first (function(...) substitute(list(...)))(a=1, b=a) # Unevaluated list, not list of unevaluated (function(...)

Duncan, Thank you for the clarification on how delayedAssign works. Should R-level interfaces to promise objects ever become available, I expect they would at time come in handy. On the subject of substitute and delayedAssign, I do have a follow-up question for the list. I'm trying to convert a named list of expression objects into an environment of promise objects. After conversion, each

R-devel, I used the 'substitute' function to create labels for objects inside an environment, without actually evaluating the objects, as the objects might be promises. However, I was surprised to see that 'substitute' returns the expression slot of the original promise even after the promise has been forcibly evaluated. (Doesn't the promise go away after evaluation?) This

Hi R-users, I would like to create an expression without evaluating it. Then paste that expression to an object. Example: Result <- paste('Result', 1, sep="") paste(Result, substitute(apply(exp.des[1:10,], 1, one.row, parms=parameters)), sep="<-") However this pastes EACH element of the unevaluated expression. Instead I just would like the expression

Interestingly, as.list(substitute(...())) also works. On Sun, Aug 12, 2018 at 1:16 PM, Duncan Murdoch <murdoch.duncan at gmail.com> wrote: > On 12/08/2018 4:00 PM, Henrik Bengtsson wrote: >> >> Hi. For any number of *known* arguments, we can do: >> >> one <- function(a) list(a = substitute(a)) >> two <- function(a, b) list(a = substitute(a), b =

Thank you for your reply Jiefei. I think in theory your solution should work. I'll have to give them a try. On Mon, 4 Nov 2019 23:41 Wang Jiefei, <szwjf08 at gmail.com> wrote: > Hi Morgan, > > My solutions might not be the best one(I believe it's not), but it should > work for your question. > > 1. Have you considered Rf_duplicate function? If you want to change

quote(expr) will make no changes in expr, it just returns its one argument, unevaluated. substitute could be used in your lapply(..., library) example to give library a name instead of a character string for an input (which might be necessary if the character.only argument were not available) lapply(c("MASS", "splines"), function(pkg) eval(substitute(library(pkg),

-------- Original-Nachricht -------- Betreff: Re: [R] Adding and Multiplying two Unevaluated Expressions Datum: Tue, 01 Dec 2009 23:49:39 +0100 Von: Benjamin M?ller <ben_mueller.bm at web.de> An: Rolf Turner <r.turner at auckland.ac.nz> Referenzen: <20091201144125.316310 at gmx.net> <8E40E49F-E8FC-4FBD-8CC5-93789FFB0E53 at auckland.ac.nz> This works fine for your

Folks: Herein is a suggestion for a little R convenience function mainly to obtain unevaluated ... function arguments. It arose from a query on R-help on how to get these arguments. The standard (I think) idiom to do this is via match.call(expand.dots=FALSE)$... However, Bill Dunlap pointed out that this repeats the argument matching of the function call and suggested a couple of alternatives

Since you're already using bang-bang ;) library(rlang) dots1 <- function(...) as.list(substitute(list(...)))[-1L] dots2 <- function(...) as.list(substitute(...())) dots3 <- function(...) match.call(expand.dots = FALSE)[["..."]] dots4 <- function(...) exprs(...) bench::mark( dots1(1+2, "a", rnorm(3), stop("bang!")), dots2(1+2, "a",

I searched and tried for hours, to no avail although it looks simple. (function(x) substitute(x))(A <- B) #A <- B (function(x) substitute(x))(A -> B) # B <- A In the first example, A occurs on the LHS, but in the second example A is somehow evaluated as if it occured on the RHS, despite my understanding that substitute() returns the unevaluated parse tree. Is there any way, or is

Hi, How to turn a character string into an unevaluated R object? I want to load some files in a directory into data matrix R objects. I could do this with read.table and assign (see below). Then, I want to turn the character string representing a file name (the evaluated expression of i) into an unevaluated R object. Basically, I want to create matrices whose names are the same as the related file

I am sure it is just me not understanding how R works, but could somebody explain why curve(cos(x)) works and curve(expression(cos(x)) does not? I have done some investigating and here is what I found. If I comment out the line of curve indicated below, both calls work fine. function (expr, from, to, n = 101, add = FALSE, type = "l", ylab = NULL, log = NULL, xlim =

Hi R Graphics Gurus I am unable to figure out this issues with unevaluated expressions. I'm trying to create a graphic where I calculate the residual from a regression and want to mark each residual with its observation number. So something like plot(0,0, type = "n", xlim = c(0,10)) for(i in 1:10){ text(i, 0, substitute(paste(epsilon[i]))) } except that i end up pasting

Dear developeRs, I maintain a package 'pls', which has a main fit function mvr(), and functions plsr() and pcr() which are meant to take the same arguments as mvr() and do exactly the same, but have different default values for the 'method' argument. The three functions are all exported from the name space. In the 'pre namespace' era, I took inspiration from lm() and

The last two lines of example(delayedAssign) give this: > e <- (function(x, y = 1, z) environment())(1+2, "y", {cat(" HO! "); pi+2}) > (le <- as.list(e)) # evaluates the promises $x <promise: 0x032b31f8> $y <promise: 0x032b3230> $z <promise: 0x032b3268> which contrary to the comment appears unevaluated. Is the comment wrong or is it supposed to

Am am missing something or does the new ...names() in R-devel not work right? > a <- function(x, ...) ...names() > a(a=stop("a"), b=stop("b")) [1] "a" "" > a(stop("x"), stop("unnamed"), c=stop("c"), d=stop("d")) [1] NA "" "" > version _ platform

Hello, x<- "something(a+b) + c" is there any function F such that F(x) gives me the unevaluated value of x, i.e. something(a+b)+c I would appreciate any help on this thanks --------------------------------- [[alternative HTML version deleted]]

I made the following example to see what are the difference between expression and quote. But I don't see any difference when they are used with eval()? Could somebody let me know what the difference is between expression and quote? expr=expression(2*3) quo=quote(2*3) eval(expr) str(expr) class(expr) typeof(expr) mode(expr) attributes(expr) eval(quo) str(quo) class(quo) typeof(quo)