search for: unquotes

--- On Fri, 6/11/09, tlumley at u.washington.edu <tlumley at u.washington.edu> wrote: > From: tlumley at u.washington.edu <tlumley at u.washington.edu> > Subject: Re: [Rd] A fix that for 'bquote' that may work? (PR#14031) > To: suharto_anggono at yahoo.com > Cc: r-devel at stat.math.ethz.ch, R-bugs at r-project.org > Date: Friday, 6 November, 2009, 11:42 PM >

I would like a function to strip quotes off character strings. I should work like this: > A <- matrix(1:6, nrow = 2, ncol=3) > AF <- as.data.frame(A) > names(AF) <- c("First","Second","Third") > AF First Second Third 1 1 3 5 2 2 4 6 > names(AF)[2] [1] "Second" > attach(AF) >

Changes from v1 to v2: - split the "simple unquoting" as helper - pass the unquoting function to split_key_value_strings - use right unquoting function when applying split_key_value_strings Pino Toscano (2): daemon: add split_key_value_strings helper daemon: use split_key_value_strings daemon/inspect_fs_unix.ml | 93 +++++++++++++++++++---------------------------- daemon/md.ml

Dear R-devel, There is a new feature in R-devel, which explicitly refers to LISP @ operator for splicing. > The backquote function bquote() has a new argument splice to enable splicing a computed list of values into an expression, like ,@ in LISP's backquote. Although the most upvoted SO question asking for exactly LISP's @ functionality in R doesn't seems to be addressed by this

Changes from v2 to v3: - split_key_value_strings renamed to parse_key_value_strings Changes from v1 to v2: - split the "simple unquoting" as helper - pass the unquoting function to split_key_value_strings - use right unquoting function when applying split_key_value_strings Pino Toscano (2): daemon: add split_key_value_strings helper daemon: use parse_key_value_strings

On Mon, Oct 16, 2017 at 05:58:10PM +0200, Pino Toscano wrote: > Add a simple helper to turn a list of strings into key/value pairs, > splitting by '=', with the possibility to apply a function to unquote > values. > > Add also a simple unquote function. > --- > daemon/utils.ml | 16 ++++++++++++++++ > daemon/utils.mli | 11 +++++++++++ > 2 files changed, 27

Full_Name: Suharto Anggono Version: 2.8.1 OS: Windows Submission from: (NULL) (125.165.81.124) Sorry for repost. There is already PR#9602, but the problem is still there. There is also a post "Re: [R] using bquote to construct function" in R-help 2008-10-02. This illustrates the problem. C:\Program Files\R\R-2.8.1\bin>R --vanilla R version 2.8.1 (2008-12-22) Copyright (C) 2008

I love the pointer analogy. Presumably the additional complication of scope breaks this however. * itself would have been a nice operator for this were it not prone to ambiguity (`a * *b` vs `a**b`, from which @ does not suffer). Would this extension require that function authors explicitly enable auto-quoting support? I somewhat envisioned functions seeing the resolved unquoted object (within

(please be gentle, it's my first time) I am interested in discussions (possibly reiterating past threads -- searching didn't turn up much) on the possibility of supporting standard evaluation unquoting at the language level. This has been brought up in a recent similar thread here [1] and on Twitter [2] where I proposed the following desired (in-principle) syntax f <-

Add a simple helper to turn a list of strings into key/value pairs, splitting by '=', with the possibility to apply a function to unquote values. Add also a simple unquote function. --- daemon/utils.ml | 16 ++++++++++++++++ daemon/utils.mli | 11 +++++++++++ 2 files changed, 27 insertions(+) diff --git a/daemon/utils.ml b/daemon/utils.ml index d87ad75db..865936280 100644 ---

...deprecated as of rlang 0.4.0. #> Please use `!!` instead. ``` We decided to disallow splicing scalars (and thus calls) in rlang even though this is a legal operation in many lisps. In lisps, the splicing operation stands for unquoting in the CDR of a pairlist. By contrast the unquote operation unquotes in the CAR. For example `(1 , at 3) is legal in Common Lisp and stands for the cons cell (1 . 3). I think such semantics are not appealing in a language like R because it is vector-oriented rather than pairlist oriented. Pairlists are mostly an implicit data structure that users are not familiar wi...

On Mon, Mar 20, 2017 at 7:36 AM, Radford Neal <radford at cs.toronto.edu> wrote: > Michael Lawrence (as last in long series of posters)... > >> Yes, it would bind the language object to the environment, like an >> R-level promise (but "promise" of course refers specifically to just >> _lazy_ evaluation). >> >> For the uqs() thing, expanding calls

Your example x = 5 exp = parse(text="f(uq(x)) + y +z") # expression: f(uq(x)) +y + z do_unquote(expr) # -> the language object f(5) + y + z could be done with the following wrapper for bquote my_do_unquote <- function(language, envir = parent.frame()) { if (is.expression(language)) { # bquote does not go into expressions, only calls

>After off list discussions with Jonathan Carrol and with >Michael Lawrence I think it's doable, unambiguous, >and even imo pretty intuitive for an "unquote" operator. For those of us who are not CS/Lisp mavens, what is an "unquote" operator? Can you expression quoting and unquoting in R syntax and show a few examples where is is useful, intuitive, and fits in to

Would this return a quosure? (i.e. a single sided formula that captures both expression and environment). That's the data structure we've adopted in tidyeval as it already has some built in support. Hadley On Friday, March 17, 2017, Michael Lawrence <lawrence.michael at gene.com> wrote: > Interesting idea. Lazy and non-standard evaluation is going to happen; the > language

Hi, Say I''ve got a directory full of stale Tomcat temp files of the form: /usr/local/blackboard/apps/tomcat/work/Catalina/localhost/webapps_assessment/strts6866.tmp and I want to delete any files that haven''t changed in a week and not keep any backup. Should this get rid of them: tidy {

s= "Hey" a = "Hello" table = rbind(s,a) write.table(table,paste("blah",".PROPERTIES",sep = ""),row.names = FALSE,col.names = FALSE) In my table, how do I output only the words and not the words with the quotations? -- View this message in context: http://r.789695.n4.nabble.com/How-to-unquote-string-in-R-tp3025654p3025654.html Sent from the R

Yes, it would bind the language object to the environment, like an R-level promise (but "promise" of course refers specifically to just _lazy_ evaluation). For the uqs() thing, expanding calls like that is somewhat orthogonal to NSE. It would be nice in general to be able to write something like mean(x, extra_args...) without resorting to do.call(mean, c(list(x), extra_args)). If we had

Interesting idea. Lazy and non-standard evaluation is going to happen; the language needs a way to contain it. I'll extend the proposal so that prefixing a formal argument with @ in function() marks the argument as auto-quoting, so it arrives as a language object without use of substitute(). Kind of like how '*' in C declares a pointer and dereferences one. subset <- function(x,

Michael Lawrence (as last in long series of posters)... > Yes, it would bind the language object to the environment, like an > R-level promise (but "promise" of course refers specifically to just > _lazy_ evaluation). > > For the uqs() thing, expanding calls like that is somewhat orthogonal > to NSE. It would be nice in general to be able to write something like >