A list of ternary operators

Why let conditionals keep hogging the spotlight?

Sup nerds, I'm back from SREcon! I had a blast, despite knowing nothing about site reliability engineering and being way over my head in half the talks. I'm trying to catch up on The Book and contract work now so I'll do something silly here: ternary operators.

Almost all operations on values in programming languages fall into one of three buckets:

1. Unary operators, where the operator goes before or after exactly one argument. Examples are x++ and -y and !bool. Most languages have a few critical unary operators hardcoded into the grammar. They are almost always symbols, but sometimes are string-identifiers (not).
2. Binary operators, which are placed between exactly two arguments. Things like + or && or >=. Languages have a lot more of these than unary operators, because there's more fundamental things we want to do with two values than one value. These can be symbols or identifiers (and).
3. Functions/methods that prefix any number of arguments. func(a, b, c), obj.method(a, b, c, d), anything in a lisp. These are how we extend the language, and they almost-exclusively use identifiers and not symbols.¹

There's one widespread exception to this categorization: the ternary operator bool ? x : y.² It's an infix operator that takes exactly three arguments and can't be decomposed into two sequential binary operators. bool ? x makes no sense on its own, nor does x : y.

Other ternary operators are extremely rare, which is why conditional expressions got to monopolize the name "ternary". But I like how exceptional they are and want to compile some of them. A long long time ago I asked Twitter for other ternary operators; this is a compilation of some applicable responses plus my own research.

(Most of these are a bit of a stretch.)

Stepped Ranges

Many languages have some kind of "stepped range" function:

# Python
>>> list(range(1, 10, 2))
[1, 3, 5, 7, 9]

There's the "base case" of start and endpoints, and an optional step. Many languages have a binary infix op for the base case, but a few also have a ternary for the optional step:

# Frink
> map[{|a| a*2}, (1 to 100 step 15) ] 
[2, 32, 62, 92, 122, 152, 182]

# Elixir
> IO.puts Enum.join(1..10//2, " ")
1 3 5 7 9

This isn't decomposable into two binary ops because you can't assign the range to a value and then step the value later.

Graph ops

In Graphviz, a basic edge between two nodes is either the binary node1 -> node2 or the ternary node1 -> node2 [edge_props]:

digraph G {
  a1 -> a2 [color="green"]
}

Graphs seem ternary-friendly because there are three elements involved with any graph connection: the two nodes and the connecting edge. So you also see ternaries in some graph database query languages, with separate places to specify each node and the edge.

# GSQL (https://docs.tigergraph.com/gsql-ref/4.1/tutorials/gsql-101/parameterized-gsql-query)
SELECT tgt
    FROM start:s -(Friendship:e)- Person:tgt;

# Cypher (https://neo4j.com/docs/cypher-manual/current/introduction/cypher-overview/)
MATCH (actor:Actor)-[:ACTED_IN]->(movie:Movie {title: 'The Matrix'})

Obligatory plug for my graph datatype essay.

Metaoperators

Both Raku and J have special higher-order functions that apply to binary infixes. Raku calls them metaoperators, while J calls them adverbs and conjugations.

# Raku

# `a «op» b` is map, "cycling" shorter list
say <10 20 30> «+» <4 5>
(14 25 34)

# `a Rop b` is `b op a`
say 2 R- 3
1

NB. J

NB. x f/ y creates a "table" of x f y
   1 2 +/ 10 20
11 21
12 22

The Raku metaoperators are closer to what I'm looking for, since I don't think you can assign the "created operator" directly to a callable variable. J lets you, though!

   h =: +/
   1 2 h 3 4
4 5
5 6

That said, J has some "decomposable" ternaries that feel spiritually like ternaries, like amend and fold. It also has a special ternary-ish contruct called the "fork".³ x (f g h) y is parsed as (x f y) g (x h y):

NB. Max - min
   5 (>. - <.) 2
3
   2 (>. - <.) 5
3

So at the top level that's just a binary operator, but the binary op is constructed via a ternary op. That's pretty cool IMO.

Assignment Ternaries

Bob Nystrom points out that in many languages, a[b] = c is a ternary operation: it is not the same as x = a[b]; x = c.

A weirder case shows up in Noulith and Raku (again): update operators. Most languages have the += binary operator, these two have the f= ternary operator. a f= b is the same as a = f(a, b).

# Raku
> my $x = 2; $x max= 3; say $x
3

Arguably this is just syntactic sugar, but I don't think it's decomposable into binary operations.

Custom user ternaries

Tikhon Jelvis pointed out that Agda lets you define custom mixfix operators, which can be ternary or even tetranary or pentanary. I later found out that Racket has this, too. Objective-C looks like this, too, but feels different somehow.

Near Misses

All of these are arguable, I've just got to draw a line in the sand somewhere.

• Regular expression substitutions: s/from/to/flags seems like a ternary, but I'd argue it a datatype constructor, not an expression operator.
• Comprehensions like [x + 1 | x <- list]: looks like the ternary [expr1 | expr2 <- expr3], but expr2 is only binding a name. Arguably a ternary if you can map and filter in the same expression a la Python or Haskell, but should that be considered sugar for
• Python's operator chaining (1 < x < 5): syntactic sugar for 1 < x and x < 5.
• Someone suggested glsl swizzles, which are very cool but binary operators.

Why are ternaries so rare?

Ternaries are somewhat more common in math and physics, f.ex in integrals and sums. That's because they were historically done on paper, where you have a 2D canvas, so you can do stuff like this easily:

10
Σ    n
n=0

We express the ternary by putting arguments above and below the operator. All mainstream programming languages are linear, though, so any given symbol has only two sides. Plus functions are more regular and universal than infix operators so you might as well write Sum(n=0, 10, n). The conditional ternary slips through purely because it's just so darn useful. Though now I'm wondering where it comes from in the first place. Different newsletter, maybe.

But I still find ternary operators super interesting, please let me know if you know any I haven't covered!

Blog Rec

This week's blog rec is Alexis King! Generally, Alexis's work spans the theory, practice, and implementation of programming languages, aimed at a popular audience and not an academic one. If you know her for one thing, it's probably Parse, don't validate, which is now so mainstream most people haven't read the original post. Another good one is about modeling open-world systems with static types.

Nowadays she is far more active on Programming Languages Stack Exchange, where she has blog-length answers on reading type notations, compiler design, and why arrows.

If you're reading this on the web, you can subscribe here. Updates are once a week. My main website is here.

My new book, Logic for Programmers, is now in early access! Get it here.