Phrase origin: Why do we "call" functions?

That's an application of `if` with one of the arguments empty.

The semantics of `if` requrie at least, `if(cond, clause)`, though more generally, `if(cond, clause, else-clause)`

You and Zambyte are both doing the same thing the top level comment is complaining about.

e.g. in C:

https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3220.pdf

    (6.8.5.1) selection-statement:
      if ( expression ) secondary-block
      if ( expression ) secondary-block else secondary-block

in C++:

https://eel.is/c++draft/gram.stmt

    selection-statement:
      if constexpropt ( init-statementopt condition ) statement
      if constexpropt ( init-statementopt condition ) statement else statement
      if !opt consteval compound-statement
      if !opt consteval compound-statement else statement

where

    condition:
      expression
      attribute-specifier-seqopt decl-specifier-seq declarator brace-or-equal-initializer
      structured-binding-declaration initializer 

More examples:

https://docs.python.org/3/reference/grammar.html

https://doc.rust-lang.org/reference/expressions/if-expr.html...

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

expression != argument

They aren't talking about C and its descendants in particular, but more generally. For example in Haskell and Scheme there is only an if function and no if statement. And you're welcome to create an if function in any language you like and use it instead of the native syntax. I like to use an if function in PostgreSQL because it's less cumbersome than a case expression.

So in the abstract, if is a ternary function. I think the original comment was reflecting on how "if (true) ... " looks like a function call of one argument but that's obviously wrong.

Arguments are expressions in Haskell. In abstract, it uses expressions.

this is not quite right. haskell and scheme have if expressions, not if statements. that's not the same as if being a function. if is not, and cannot be, a function in scheme, as it does not have scheme function semantics. specifically, it is not strict, as it does not evaluate all its subexpressions before executing. since haskell is non-strict, if can be implemented as a function, and iirc it is

> since haskell is non-strict, if can be implemented as a function, and iirc it is

"If" can be implemented as a function in Haskell, but it's not a function. You can't pass it as a higher-order function and it uses the "then" and "else" keywords, too. But you could implement it as a function if you wanted:

  if' :: Bool -> a -> a
  if' True x _ = x
  if' False _ y = y

Then instead of writing something like this:

  max x y = if x > y then x else y

You'd write this:

  max x y = if' (x > y) x y

But the "then" and "else" remove the need for parentheses around the expressions.