x[i,j] and x[i;j] are parsed the same

[joehuchette]

Consider

julia> dump(:(x[i,j]))
Expr
  head: Symbol ref
  args: Array(Any,(3,))
    1: Symbol x
    2: Symbol i
    3: Symbol j
  typ: Any

julia> dump(:(x[i;j]))
Expr
  head: Symbol ref
  args: Array(Any,(3,))
    1: Symbol x
    2: Symbol i
    3: Symbol j
  typ: Any

What's the rationale for this behavior? This is now seems ambiguous, since #8250 gives

julia> dump(:(x[i,j;k]))
Expr
  head: Symbol ref
  args: Array(Any,(4,))
    1: Symbol x
    2: Expr
      head: Symbol parameters
      args: Array(Any,(1,))
        1: Symbol k
      typ: Any
    3: Symbol i
    4: Symbol j
  typ: Any

[joehuchette]

cc @mlubin

[mlubin]

cc @jakebolewski

[jakebolewski]

#8250 didn't change this behavior. In 0.3 [x,y] and [x; y] both are parsed as 1-d vectors. Isn't this just another consequence of automatic concatenation? The second form can be thought of as
[[1],[2]].

The 2D case works as you would expect:

julia> [1 1; 2 2]
2x2 Array{Int64,2}:
 1  1
 2  2

julia> [[1 1]; [2 2]]
2x2 Array{Int64,2}:
 1  1
 2  2

julia> [[1 1], [2 2]]
2x2 Array{Int64,2}:
 1  1
 2  2

[JeffBezanson]

The problem seems to be that parsing x[i] calls parse-cat.

[jakebolewski]

Which is necessary to support array syntax for typed arrays [1 1; 2 2] -> Int[1 1; 2 2].

[JeffBezanson]

That makes sense. If we change [x,y] to not concatenate (:+1:), then [x,y] and [x;y] should parse differently, as should a[x,y] and a[x;y]. In fact it seems like it would be better to parse these differently already, even if they mean the same thing for now.

[mlubin]

Right, it seems like they should be parsed differently regardless of the current behavior of [a,b].

[joehuchette]

+1 to parsing them differently (and for dropping automatic concatenation...)

[mlubin]

Any way we could resolve this before a decision is made on #8599?

[StefanKarpinski]

I've marked this as "up for grabs". It's a slightly tedious though relatively straightforward parser change. I think that if you want to change the way this parses, as long as it doesn't break stuff, it's fine.

[mlubin]

Is this fixed now?

julia> dump(:(x[i;j]))
Expr 
  head: Symbol typed_vcat
  args: Array(Any,(3,))
    1: Symbol x
    2: Symbol i
    3: Symbol j
  typ: Any

[jakebolewski]

Yup.

julia> Meta.show_sexpr(:(x[i,j]))
(:ref, :x, :i, :j)
julia> Meta.show_sexpr(:(x[i;j]))
(:typed_vcat, :x, :i, :j)
julia> Meta.show_sexpr(:(x[i,j;k]))
(:typed_vcat, :x, (:parameters, :k), :i, :j)

[mlubin]

Shouldn't x[i,j;k] be a ref not a typed_vcat? The presence of parameters shouldn't change the type of the expression.

[jakebolewski]

Yes, but I feel that is a separate issue. We currently give a really bad error message as well:

julia> Int[1,2;3,4]
ERROR: unsupported or misplaced expression parameters

whereas in v0.3 we gave something more helpful

julia> Int[1,2;3,4]
ERROR: syntax: unexpected semicolon in array expression

related to #9601