Ternary Operators

First example that came to mind for me is in SQL:

  x IS BETWEEN y AND z

A not-quite-binary example would be languages where comparisons chain:

  x < y <= z
    Equivalent to:
  (x < y) && (y <= z)
    (Possibly modulo short-circuiting)

In maths, you would sometimes see clever constructions with reversed relation symbols to succinctly describe many things at once; when written down I would sometimes see relations going out in other directions after left and right were exhausted.

The ‘ternary’ assignment is customisable in OCaml: x.(y) <- z is (maybe was?) exactly equivalent Array.set x y z, including in the parse tree, and so could be can be customised by shadowing the Array module; and custom variants may be defined too, e.g.

  type 'a t = {mutable a : 'a array; mutable p : int }
  
  let push t x =
    ensure_capacity t 1;
    t.a.(t.p) <- x;
    t.p <- t.p + 1

  let (.:()<-) t j x =
    if j >= t.p then raise Out_of_bounds;
    t.a.(j) <- x

  (* one can now use t.:(i) <- x *)

Another weirder mixfix example would be binding operators, but then you accept lots of other syntax too like if then else. Binding operators let you define weird functions with names like (let) or (and) and then:

  let* x = y in z
  (* equivalent to: *)
  (let*) y (fun x -> z)

  let* x1 = y1 and x2 = y2 in z
  (* equivalent to: *)
  (let*) ((and*) y1 y2) (fun (x1, x2) -> z)

What about the derivative operator in maths? When you write say d^nf/dx^n in Leibniz notation (or the equivalent in Lagrange notation f^(n)(x)), you have 3 arguments. The "f" is the function you are taking the derivative of, the n is what derivative to take and then the (x) is what to name the argument in the resulting function.

Obviously in the common case you're just writing something like f'(x) or f''(x) where the ' stands for ^(1) but it's still a ternary operator.

Another common example in maths is the "limit" operator where you have lim_x->a <someexpr> and the arguments are x, a and someexpr.

Agreed with a sibling that this is somewhat abusing the terminology. In/pre/postfix of the operators is a different thing from how many terms an operator acts on. Indeed, in RPN, it was not uncommon to try and execute an operator but not have enough terms on the stack.

Seems that we typically call the ?: combination a ternary operator largely stems from the distinction between operators, functions, and keywords. One that we largely don't keep in a consistent fashion. Add in functions versus methods, and things get really fun.

Programming also has the odd case where functions have an easy syntax to say that there are multiple inputs, but we don't have a common syntax to say there are multiple outputs. Which is something that is quite common in every domain.

After some thinking, the ternary conditional operator can be decomposed into 2 composing binary operators like such:

? takes a bool, a T, and returns option<T>

true?b == Result b

false?b == None

: takes an Option<T> and a T and returns T

Result x : y == x

None : y == y

However, in most languages (looking at you php) the ?: act as a type of parenthesis: in a?b:c, any expression goes into b, no matter it's precedence.

JavaScript method call notation is arguably a ternary operator, or a candidate for the "Near Misses" list (because « foo.bar(x) » isn't the same as « var meth = foo.bar; meth(x) »).

The whole article hinges on the fact that the author seems to be unfamiliar with the term arity (?), which feels weird given they're clearly familiar with a number of programming languages etc. The definitions for unary, binary, etc are rather arbitrary and not how they're usually used.

Verilog has a sliding-window part select, which produces a slice that has a fixed width. It's an lvalue expression (it can be assigned to). It's ternary.

array[addr +: W]

or

array[addr -: W]

The former chooses W elements beginning at addr, the latter chooses W elements ending at addr.

(postgre)sql has lots of quirky stuff that kinda qualifies. For example

     substring ( string text [ FROM start integer ] [ FOR count integer ] ) → text

at a glance you might think that as just a normal function call, but the arguments do not follow the regular function call argument syntax, instead it has this special sauce ternary syntax.

Binary operators don't "go between" 2 operands, they just consume two operands.

+ 2 3

Is a perfectly valid binary operator.

It mentions ranges, but not slices?

Note that the "conditional/selection operator" is normally thought of as a logical operator, but variants exist that operate bitwise `r = (if_false & ~condmask) | (if_true & condmask)` or on a vector. Additionally, there maybe a special versions that operate at compile-time instead of runtime.

Modular exponentiation is commonly implemented as ternary for major performance improvements, even though technically it can be done as composition of two binaries.

Modular congruence `3 === 1 (mod 2)` is common in math.

Many arithmetic and bitwise operations take a third argument for the carry bit. Rotates are notable for actually performing a different operation in that case.

There are various SIMD operations.

There's also SSA.

APL brings another couple of ternaries (besides for those mentioned with regards to J):

  x f[k] y

This one is universal among traditional APLs (though some modern APLs, including J, remove it). However, it is traditionally only used for a concept of application along an axis of APL's multidimentional arrays, and only for a strictly limited set of built-in "operators". That said, GNU APL and NARS2000 both allow it on user-defined functions (which have infix syntax, just like "operators").

  x n.f y

This is infix application of the function f from the namespace n, so n must have namespace value, but it is still a proper argument because n isn't just an identifier, but can also be an expression:

  x (expression).f y

In fact, the expression can be an entire (multidimentional!) array of namespaces:

  x (namespace1 namespace2).f y

is equivalent to

  (x[1] namespace1.f y[1])(x[2] namespace2.f y[2])

Furthermore, f can be a built-in "operator" which appears to exist in every namespace, but which also takes the current namespace into consideration. For example, x⍳y is the position of y in x and if io0 is a namespace wherein indexing is 0-based and io1 is a namespace wherein indexing is 1-based, we can write:

  'AX' 'BX' (ns0 ns1).⍳ 'X'

and get the result 1 2 because X is at position 1 in AX with 0-based indexing but at position 2 of BX with 1-based indexing. (I'm not saying you should write code like this, but you could.)

I’m surprised not to see fused multiply-add here:

    FMA(x,y,z) ~ x += y*z

You see it all over the place in numerical computing and deep learning.

In Tarski's axiomatization of plane geometry, there's a betweenness triadic relationship, Bxyz, point y is between x and z.

I'm not sure I'd say that it can't be done. In some languages it could be implemented if the language itself supports optionals. So "bool ? x" could result in an Optional<type(x)>, while "Optional<type(x)> : y" could be the typical implementation of value_or that is found on optionals.

Whether it's a good idea to implement it that way is something I haven't come to an opinion on yet. My only argument is that "can't be decomposed" feels like it's a little to far reaching.

Edit: to add on to this, while it's not really a ternary operator in the sense he seems to be looking for. It it common for assembly to have fma instructions. But this feels like a really weird edge case since x * y + z technically can be decomposed into the 2 separate operators, but the fma instruction itself can't be decomposed without losing precision.

In Agda, if_then_else_ is a ternary operator: https://wiki.portal.chalmers.se/agda/ReferenceManual/Mixfix

For Agda being lazily evaluated, ternary if_then_else_ corresponds to usual if cond then true_expr else else_expr syntax of most mainstream languages.

Maude also have a lot of infix, prefix, postfix and mixfix, including ternary operations: https://maude.cs.uiuc.edu/maude1/manual/maude-manual-html/ma...

Missed python's slicing:

  >>> 'abcdefghijklmnopqrstuvwxyz'[1:20:4]
  'bfjnr'

It's start/end/skip, with default values of 0, length, 1; each can be omitted so it's rare to see the third one unless someone is showing off how to reverse a string:

  >>> 'abcdefghijklmnopqrstuvwxyz'[::-1]
  'zyxwvutsrqponmlkjihgfedcba'

Though really these are slice objects, it's just the syntax only works inside array access:

  >>> slice
  <class 'slice'>
  >>> z = slice(1, 20, 4)
  >>> 'abcdefghijklmnopqrstuvwxyz'[z]
  'bfjnr'

They are all just functions. There is really no distinction between an operator and a function in programming languages. And by using currying you could even do with just unary operators.

I don't understand why `a += b` is called binary (I agree!) but `a f= b` would be called ternary. I guess it's thinking of `f` as one of the arguments?

SQL has a BETWEEN AND operator:

    SELECT count() FROM hits
    WHERE EventDate BETWEEN '2024-01-01' AND '2024-11-11'

https://clickhouse.com/docs/en/sql-reference/operators

clamp and mix are good candidates. Ternary operator syntaxes are rarer than ternary operations, because there's not much that can justify being so syntactically indulgent.

Conditionals are common enough that they can justify the indulgence, but even then I prefer an if-else expression syntax over ?:, it generalises better to other constructs such as pattern matching.

Like others here, I find the way this article discusses things a bit odd. I think a more interesting question is to emphasize SYNTAX (the word doesn’t seem to appear in the article). Which languages have special syntax that maps to an AST node as OP(a,b,c)? Focus on syntax and things like range(start,end,step) dont fall into this category.

Beware the number of evaluation dragons!

1 < x < 5 is not just syntactic sugar for 1 < x and x < 5.

Every lisp macro programmer knows that x must be evaluated only once, so it needs to be gensym'ed. Only if x is a constant or evaluates to itself it can be optimized without a gensym.

I rather like the Smalltalk message selector structure Boolean>>ifTrue:ifFalse:

  (cond) ifTrue: [then-block] ifFalse: [else-block]

For some reason the way Swift handles syntax I find less memorable or composable.

When talking about J forks, the author says they don't know how to parse `x (f1 f2 f3 f4 f5) y`. After reading the relevant documentation, I believe this parses as

  (x f1 y) f2 ((x f3 y) f4 (x f5 y))

Maybe it was Dave Long that pointed out that lerp is a generalization of the conditional ternary operator. When the condition is 0, it returns the from-point, and when it's 1, it returns the to-point, but if you generalize it to the whole real number line, you lose nothing semantically except for short-circuiting. Lerp is a pretty common function in graphics—the simplest way to understand Bézier splines is as recursive lerping—but for whatever reason it generally isn't written as an infix operator, which seems to be what Hillel is looking for here.

I think that Hillel's criterion that the ternary operator "can't be decomposed into two sequential binary operators" is too demanding. He says, "bool ? x makes no sense on its own, nor does x : y". Well, that's just because C's grammar is written such that they won't parse. If you extend the grammar to permit them, it's not very hard to extend the semantics as well. For example, you could permit every expression to either succeed, yielding a value, or fail, yielding no value; languages that work in something like this way include regular expressions, META-II, Icon, Unicon, and Prolog, though each of them deviates from it in detail. Then, to get the C/JS semantics, bool ? x succeeds with the value of x if bool is true, or fails if bool is false, and x : y succeeds with the value of x if x succeeds, but if x fails, does y.

You could model the exception mechanism in languages with exceptions as failing to return a value, in which case x : y ends up being a general-purpose exception-handling mechanism, so you can say something like total[k] = (total[k] : 0) + 1 to increment a possibly-nonexistent hash key. Mark Lentczner's language Wheat has an operator like this, spelled !!, which I stole for my own language Bicicleta.

(That's assuming you parse bool ? x : y as (bool ? x) : y. You can also invent semantics that give you the right behavior with the parsing bool ? (x : y) but the ones that occur to me seem less appealing.)

Similarly for Elixir's stepped range 1..10//2. Hillel says, "This isn't decomposable into two binary ops because you can't assign the range to a value and then step the value later." Well, maybe not (I don't know Elixir), but it seems clear enough what r//2 should do if r is the name of a range value: it should produce a new range stepping either by 2 or by twice the previous step.

C++ does something like this for Hillel's (or munificent's) example of a[b] = c: the expression a[b] evaluates to a reference, which in rvalue context decays to an ordinary value, but which can indeed be assigned to a variable. Unfortunately, C++'s reference semantics are somewhat weak, with the consequence that actually overriding operator[] in C++ to return a reference is pretty bug-prone, because you can autovivify things you didn't want to autovivify.

By Hillel's apparent syntactic and decomposability criteria, I think every single two-argument method in Smalltalk is a "ternary operator". 1 to: anInt do: [ :i | r := ( r * self ) ], for example, or arr at: i put: v. As he sort of points out, Objective-C inherited this from its Smalltalk roots, but he sort of throws up his hands at it.

interesting collection… I would propose the raku sequence op `…` as a ternary, for example:

  1,2,3 … Inf;   #(1,2,3,4,5,6…) arithmetic sequence
  1,2,4 … Inf;   #(1,2,4,8,16,32…) geometric sequence 

so looks at all three of the operands to work out the result

Why doesn’t the article mention the most obvious example of all, s[i:j]?

How about SQL joins? "foo JOIN bar ON foo.id = bar.fooid"

What about subject–predicate–object triples?