the .. operator

Question

the .. operator

Closed this issue 11 years ago · 9 comments

is the behavior of the .. variable intentional?

I found this because I wanted to see whether I could propose that x..y(...) could be syntax for y(x, args...) or possibly instead syntax that x..y == Intrinsics.getfield(x,y) and x.y == Base.getdot(x,y)

julia> x..y = y:-1:x
# methods for generic function ..
..(x,y) at none:1

julia> 1..7
7:-1:1

julia> .... = 1
1

julia> ....
1

julia> x....y = x+y
ERROR: syntax: malformed function argument (call * .... y)

julia> x.....y = x+y
ERROR: syntax: malformed function argument (. .... 'y)

julia> x......y = x+y
ERROR: syntax: malformed function argument (call * x ....)

julia> x.......y = x+y
ERROR: syntax: extra token after end of expression

Answer 1 · 2013-03-19T18:55:07.000Z

I don't know, what should it do?

Answer 2 · 2013-03-19T19:18:39.000Z

Syntax error? .. and .... aren't exactly in the common list of valid variable names, although they seem great for obfuscating code contests

Or reserve them for something useful, such as my other two proposals (making x..y(args...) OO syntax for y(x, args...), or making x..y == Intrinsics.getfield(x,y) and x.y == Base.getdot(x,y) which is overloadable and defaults to Intrinsics.getfield)

Answer 3 · 2013-03-20T06:40:27.000Z

The contest we should have is how many colons and dots you can have in one julia expression.

Answer 4 · 2013-03-20T06:59:16.000Z

Since .. is a sideways colon, it ought to be the second most popular symbol.

Answer 5 · 2013-03-20T07:00:26.000Z

Also .... is not that strange a variable name. In lisp, the empty string can be a variable name :)

Answer 6 · 2013-03-20T13:52:08.000Z

Lisp is so cool

Answer 7 · 2013-04-04T06:41:35.000Z

I added a syntax error for 4 or more dots.
Although everybody wants a.b syntax for various things, I think a..b is actually worthless. Might as well have it available as an operator in case some use arises, but I don't think anybody would be happy with x..f(y) for method calls.

Answer 8 · 2014-02-12T12:44:54.000Z

How about using a..b as a shortcut to a[:b]? I have the feeling the dictionary-like types with symbols as keys are being used a lot (I'm thinking in DataFrames and PyCall). This is not as powerful as an overloadable dot operator, but maybe it is much simpler/faster to implement...

Answer 9 · 2014-02-12T14:01:31.000Z

Clever idea, but overloading the dot operator is going to happen, so it becomes a bit of a waste of syntax.