Lower chained inequalities in an extendable way

[dpsanders]

The following lowering makes it impossible to extend 3 <= x <= 4 for user-defined types, e.g. in ModelingToolkit.jl:

julia> Meta.@lower 3 <= x <= 4
:($(Expr(:thunk, CodeInfo(
    @ none within `top-level scope'
1 ─ %1 = 3 <= x
└──      goto #3 if not %1
2 ─ %3 = x <= 4
└──      return %3
3 ─      return false
))))

Could it be lowered to just 3 <=x && x <= 4 or similar?

[simeonschaub]

All conditionals are lowered to branches like this, so 3 <=x && x <= 4 should produce exactly the same code after lowering. It's not possible to implement short-circuiting as an overloadable function, that's why && can't be overloaded as well, so I don't think we can make any of this overloadable by MTK.

[dpsanders]

Thanks, good point. Hmm, it just feels like there should be some kind of intermediate level which could be extendable.

[simeonschaub]

We could give up on short-circuiting behavior, but that would definitely be a breaking change and I am unsure it's justified enough.

[dpsanders]

I guess the point is that Julia currently expects x <= 3 to return a Boolean result, but if x is a custom type then this is not necessarily correct.

You could argue that is an abuse of <=, but this is apparently still an issue even if you define a different operator, say ≼ (\preccurlyeq):

julia> Meta.@lower x ≼ y ≼ z
:($(Expr(:thunk, CodeInfo(
    @ none within `top-level scope'
1 ─ %1 = x ≼ y
└──      goto #3 if not %1
2 ─ %3 = y ≼ z
└──      return %3
3 ─      return false
))))

[simeonschaub]

The current semantics of chained inequalities are that for example in a < b < f(x), f(x) will never get executed if a >= b. This means that the first half a < b always needs to return a boolean value, because whether f(x) gets executed depends on that value. Some languages assign some kind of "truthiness" to non-boolean values, but that would be a very fundamental change.

[Moelf]

looks like you want an analog to ifelse where both branch are checked (probably for interval asthmatics?), so semantically something like:

isbetween(x, a, b)

[dpsanders]

Partly. It's to be able to specify constraints in Julia, say for constrained optimization, without needing to resort to macros.
E.g. it would be great to be able to write the following:

using ModelingToolkit
@variables x, y, z   # define symbolic variables

constraint = x ≤ 2y ≤ z   # currently fails

[mbauman]

Duplicate of #36989 😀

Edit: Actually let's close that one and keep this one since there's discussion here.

Also related is the pre-1.0 decision at #16088.

[Moelf]

I think the solution for you is to use a macro

constraint = @interval x <= 2y <= z

[dpsanders]

@mbauman Oops, sorry!

@Moelf: I understand that macros give a "solution" and you can already do similar things with macros in IntervalArithmetic.jl and IntervalConstraintProgramming.jl. As I said in my previous comment: I would like to do this "without needing to resort to macros".
Currently I am allowed to create an object representing "the symbolic expression x <= y", but not "the symbolic expression x <= y <= z". That seems wrong.

[JeffBezanson]

Unfortunately I don't see a non-breaking way to implement this.