multiline ternary operator fails to parse with `:` on second line

[rokke-git]

if you have the : of ?: on the second line, it fails to parse correctly:

julia> true ? 1
            : 2
ERROR: ParseError:
# Error @ REPL[166]:1:9
true ? 1
#       └ ── `:` expected in `?` expression
Stacktrace:
 [1] top-level scope
   @ REPL:1

julia> Meta.@lower(true ? 1
                        : 2)
:($(Expr(:thunk, CodeInfo(
1 ─     goto #3 if not true
2 ─     return 1
3 ─     return 2
))))

this doesn't matter for simple expressions like this, but kinda hurts when you need readable nested if statements:

julia> function divrem(x::Integer, y::Integer, rnd::typeof(RoundNearest))  # parse error
           (q, r) = divrem(x, y)
           parity = isodd(y) | iseven(q)
           x >= 0 ? y >= 0 ? r >=        (y÷2) + parity ? (q+true, r-y) : (q, r)
                           : r >=       -(y÷2) + parity ? (q-true, r+y) : (q, r)
                  : y >= 0 ? r <= -signed(y÷2) - parity ? (q-true, r+y) : (q, r)
                           : r <=        (y÷2) - parity ? (q+true, r-y) : (q, r)
       end

julia> function divrem(x::Integer, y::Integer, rnd::typeof(RoundNearest))  # workaround
           (q, r) = divrem(x, y)
           parity = isodd(y) | iseven(q)
           (
           x >= 0 ? y >= 0 ? r >=        (y÷2) + parity ? (q+true, r-y) : (q, r)
                           : r >=       -(y÷2) + parity ? (q-true, r+y) : (q, r)
                  : y >= 0 ? r <= -signed(y÷2) - parity ? (q-true, r+y) : (q, r)
                           : r <=        (y÷2) - parity ? (q+true, r-y) : (q, r)
           )
       end

julia> function divrem(x::Integer, y::Integer, rnd::typeof(RoundNearest))  # alternate workaround, harder to read
           (q, r) = divrem(x, y)
           parity = isodd(y) | iseven(q)
           x >= 0 ? y >= 0 ? r >=        (y÷2) + parity ? (q+true, r-y) : (q, r) :
                             r >=       -(y÷2) + parity ? (q-true, r+y) : (q, r) :
                    y >= 0 ? r <= -signed(y÷2) - parity ? (q-true, r+y) : (q, r) :
                             r <=        (y÷2) - parity ? (q+true, r-y) : (q, r)
       end

julia> function divrem(x::Integer, y::Integer, rnd::typeof(RoundNearest))  # unreadable abomination from Base
           (q, r) = divrem(x, y)
           if x >= 0
               if y >= 0
                   r >=        (y÷2) + (isodd(y) | iseven(q)) ? (q+true, r-y) : (q, r)
               else
                   r >=       -(y÷2) + (isodd(y) | iseven(q)) ? (q-true, r+y) : (q, r)
               end
           else
               if y >= 0
                   r <= -signed(y÷2) - (isodd(y) | iseven(q)) ? (q-true, r+y) : (q, r)
               else
                   r <=        (y÷2) - (isodd(y) | iseven(q)) ? (q+true, r-y) : (q, r)
               end
           end
       end

julia> function divrem(x::Integer, y::Integer, rnd::typeof(RoundNearest))  # trololololol
           if x >= 0
               if y >= 0
                   if r >= (y÷2) + (isodd(y) | iseven(q))
                       divrem(x, y) .+ (true, -y)
                   else
                       divrem(x, y)
                   end
               else
                   if r >= -(y÷2) + (isodd(y) | iseven(q))
                       divrem(x, y) .- (true, -y)
                   else
                       divrem(x, y)
                   end
               end
           else
               if y >= 0
                   if r <= -signed(y÷2) - (isodd(y) | iseven(q))
                       divrem(x, y) .- (true, -y)
                   else
                       divrem(x, y)
                   end
               else
                   if r <= (y÷2) - (isodd(y) | iseven(q))
                       divrem(x, y) .+ (true, -y)
                   else
                       divrem(x, y)
                   end
               end
           end
       end

julia> function divrem(x::Integer, y::Integer, rnd::typeof(RoundNearest))  # also technically equivalent
           if x >= 0
               if y >= 0
                   if r >= (y÷2) + (isodd(y) | iseven(q))
                       divrem(x, y) .+ (true, -y)
                   else
                       divrem(x, y)
                   end
               elseif r >= -(y÷2) + (isodd(y) | iseven(q))
                   divrem(x, y) .- (true, -y)
               else
                   divrem(x, y)
               end
           elseif y >= 0
               if r <= -signed(y÷2) - (isodd(y) | iseven(q))
                   divrem(x, y) .- (true, -y)
               else
                   divrem(x, y)
               end
           elseif r <= (y÷2) - (isodd(y) | iseven(q))
               divrem(x, y) .+ (true, -y)
           else
               divrem(x, y)
           end
       end

(those (y÷2)'s should prob all be (y÷0x2)'s so that it doesn't need to cast y for the division, but that's a totally different tangent)

[KlausC]

That is, what the Formatter returns for the first variant:

function divrem(x::Integer, y::Integer, rnd::typeof(RoundNearest))  # workaround
    (q, r) = divrem(x, y)
    parity = isodd(y) | iseven(q)
    x >= 0 ?
    y >= 0 ? r >= (y÷2) + parity ? (q+true, r-y) : (q, r) :
    r >= -(y÷2) + parity ? (q-true, r+y) : (q, r) :
    y >= 0 ? r <= -signed(y÷2) - parity ? (q-true, r+y) : (q, r) :
    r <= (y÷2) - parity ? (q+true, r-y) : (q, r)
end

It produces syntactical correct output, which is not readable, because the indentation is gone.

[rokke-git]

that sounds like a bug to put in with Formatter? I haven't used it so idk where it lives.

edit: ah, figured it out. it's doing something pretty similar to the function defined in base, but without distinguishing the innermost one-line ternary operators from the dismembered outer ternaries. if you add newlines after the y >= 0 ? part and indent it's almost okay:

julia> function divrem(x::Integer, y::Integer, rnd::typeof(RoundNearest))  # Formatter
           (q, r) = divrem(x, y)
           parity = isodd(y) | iseven(q)
           x >= 0 ?
               y >= 0 ?
                   r >= (y÷2) + parity ? (q+true, r-y) : (q, r) :
                   r >= -(y÷2) + parity ? (q-true, r+y) : (q, r) :
               y >= 0 ?
                   r <= -signed(y÷2) - parity ? (q-true, r+y) : (q, r) :
                   r <= (y÷2) - parity ? (q+true, r-y) : (q, r)
       end

you really need to be able to line things up vertically for it to actually read well, though

just for fun

here's the 'also technically equivalent' version as ?: statements. made more sense to add on to this post before my edit; but it's still funny

julia> function divrem(x::Integer, y::Integer, rnd::typeof(RoundNearest))
           (q, r) = divrem(x, y)
           parity = isodd(y) | iseven(q)
           x >= 0 ?
               y >= 0 ?
                   r >= (y÷2) + parity ?
                       (q+true, r-y) :
                   (q, r) :
               r >= -(y÷2) + parity ?
                   (q-true, r+y) :
               (q, r) :
           y >= 0 ?
               r <= -signed(y÷2) - parity ?
                   (q-true, r+y) :
               (q, r) :
           r <= (y÷2) - parity ?
               (q+true, r-y) :
           (q, r)
       end