# In Argentum, there’s no ternary operator A?B:C

### but there are two binary operators: "?" and ":"

Let's consider an example:

``````a = 4;              // `a` has type `int` and value 4
b = a < 0 ? -1 : 1; // `b` has type `int` and value 1``````

Actually, the expression `a ? b : c` in this example consists of two nested binary operators. They can be written separately as well:

``````x = a < 0 ? -1;
b = x : 1;``````

The type of variable `x` will be `optional<int>,` or in Argentum syntax: `?int`. Let's delve into the semantics of these two lines more closely:

``````x = a < 0 ? -1; // `x` will be -1 if `a` < 0 or "nothing" for all other cases.
b = x : 1;      // assign the value of `x` to `b`, but if it's "nothing", then assign 1.``````

It can be said that the operator `?` produces an optional, and `:` consumes it. When used together, they function like the old good ternary operator:

``b = (a < 0 ? -1) : 1;``

When the result of an expression is not needed, the operator `?` works like an `if`:

``a < 0 ? log("it's negative");``

And the pair of operators `?:` works like an `if...else`:

``````a & 1 == 0
? log("it's even")
: log("it's odd");``````

So, Argentum split the ternary operator into two binary ones. What did this achieve?

• Short conditional expressions without an 'else' part that return values. The language became more orthogonal.
• Nothing got complicated—no new syntactic constructs were added.
• Two constructors for optional values appeared:
• Instead of (C++) `optional<decltype(x)> maybeX{x}`
we can write `maybeX = true ? x`
• Instead of `optional<decltype(x)> maybeX{nullopt}`
we can write `maybeX = false ? x`
• Unpacking with default value also became simpler:
Instead of `auto a = maybeX ? *maybeX : 42`
we can write `a = maybeX : 42`
• In case of data absence, it's not necessary to use a default value; we can call a handler for the problematic situation or trigger panic: `x : terminate()`
• It's often, when returning an optional result from a function,
we write: `return condition ? result : nullopt`
In Argentum, this will be: `condition ? result`
• We can not only combine the `?` and `:` operators but also combine the `:` operators among themselves. For example:
`user = currentUser : getUserFromProfile() : getDefaultUser() : panic("no user");` This short expression attempts to get a user object from multiple places and triggers application exit if nothing succeeds.