Duncan, Adrian and all,
I decided to look a bit at how various operators are seen by typeof() in light
of this discussion and it seems there are quite a few categories as shown below
and I suspect more exist. R, like many languages was not initially designed to
have some object-oriented aspects and some have been cobbled on over the years
including multiple emulations of what it means to be an object. So, explicit or
implicit functions may be of different kinds.
> typeof(`<-`)
[1] "special"
> typeof(`->`)
Error: object '->' not found
> typeof(`+`)
[1] "builtin"
> typeof(`=`)
[1] "special"
> typeof(`|>`)
Error: object '|>' not found
> typeof(`%>%`)
[1] "closure"
In principle, and someone can probably point to languages that do something
like this, all assignments could be centralized into some kind of primitive
function call along the lines of:
assign("A", 5)
Then you could build on that so that the definition of = and <- and even <--
would mean that the following might result in something like the above:
A = 5
A <- 5
Bothe become an assign statement like the above meaning a function with a side
effect.
A <- 5
Would simply be an assign with an added argument specifying the global
environment.
The other two forms would just invert it so that
5 -> A
5 --> A
Simply generate the same assignment statement.
I am not sure if such a system would work well for all needs but I can see a
language doing that even if it makes it slower. And, in such a system, you
could create your own assignment operators or redirect the ones already
existing as I considered a possibility.
But for some purposes, it may be way easier to have the ability to have some
elements of absolutely fixed syntax that allow functionality even before an
expression is fully evaluated. As one example, a comma that is not hidden in
quotes is generally considered to be a way to determine how to break an
expression into parts. Otherwise, how would you know that f(a,b,c) has three
arguments. So what happens if your country uses a comma like other use a period
as in numbers? Yes, in some environments you can specify that this is being
done but it is really not trivial to make a system that is completely flexible
in all aspects and allows you to flip from one way of using numbers to the
other while also changing any other places the symbols are used in different
ways.
So the problem becomes whether you can graft the mini language required for
dealing with graphs that can include A -> B and A <- B and perhaps A <-> B in
ways that are either not seen as they are parsed or even evaluated or that
over-ride normal behavior.
One obvious idea is to avoid re-using the same symbols. R frequently just wraps
symbols in percent signs so you might consider transforming anything to be A
%->% B or maybe something like A %_>% or other notations that the parser does
not see. It may be a pain but %FORWARD% versus %BACKWARD% or other gimmicks
might work enough and you can always substitute out to the original version
after you pass this danger zone.
And if your formulas are wrapped into some kind of object, they can store
several versions or have the ability to do conversions.
But those ideas belong in a more mainstream R mailing list.
-----Original Message-----
From: Duncan Murdoch <murdoch.dun...@gmail.com>
Sent: Saturday, March 2, 2024 6:32 AM
To: Adrian Dușa <dusa.adr...@gmail.com>; avi.e.gr...@gmail.com
Cc: r-devel <r-devel@r-project.org>
Subject: Re: [Rd] capture "->"
You can't change the parser. Changes like `+` <- `-` change the
function that is called when the expression contains a function call to
`+`; this happens in `eval()`, not in `parse()`. There are never any
function calls to `->`, because the parser outputs a call to `<-` with
the operands reversed when it sees that token.
Duncan Murdoch
On 02/03/2024 6:06 a.m., Adrian Dușa wrote:
> That would have been an elegant solution, but it doesn't seem to work:
>
>> `->` <- `+`
>> 1 -> 3 # expecting 4
> Error in 3 <- 1 : invalid (do_set) left-hand side to assignment
>
> It is possible to reassign other multiple character operators:
>> `%%` <- `+`
>> 1 %% 3
> [1] 4
>
> The assignment operator `->` is so special for the R parser, that it seems
> impossible to change.
>
> On Fri, Mar 1, 2024 at 11:30 PM <avi.e.gr...@gmail.com> wrote:
>
>> Adrian,
>>
>> That is indeed a specialized need albeit not necessarily one that cannot
>> be done by requiring an alternate way of typing a formula that avoids being
>> something the parser sees as needed to do at that level.
>>
>> In this case, my other questions become moot as I assume the global
>> assignment operator and somethings like assign(“xyz”, 5) will not be in the
>> way.
>>
>> What I was wondering about is what happens if you temporarily disable the
>> meaning of the assignment operator <- and turn it back on after.
>>
>> In the following code, for no reason, I redefine + to mean – and then undo
>> it:
>>
>>
>>> temp <- `+`
>>> `+` <- `-`
>>> 5 + 3
>> [1] 2
>>> `+` <- temp
>>> 5 + 3
>> [1] 8
>>
>
> [[alternative HTML version deleted]]
>
> ______________________________________________
> R-devel@r-project.org mailing list
> https://stat.ethz.ch/mailman/listinfo/r-devel
______________________________________________
R-devel@r-project.org mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
