Hacker News Reader

Comment by andix | Hacker News Reader

True, functions with return values are so much better in such a case. I really miss if expressions and switch expressions in most languages. Most functional languages (and also c#) have them. Something like (let’s do JavaScript in this example):

  const value = if (a) {
    return true
  } else {
    return switch (b) {
      case 1: return false
      default: return undefined
    }
  }

View on HN

Ada calls these "if expression" and the switch-variant "case expressions". It's the same syntax as the control flow ones, just wrapped with parens.

    value := (if a then True
              else (
                 case b is
                    when 1 => False,
                    when others => Undefined
              ));

Interestingly Rust does this and I agree JavaScript with const feels only 80% there without this feature.

As an aside for those wondering what the name for this is to see what other languages support it, this is a case 'if' being an expression rather than a statement which allows it to be composed within other expressions.

Exactly. Here is an overview of switch expressions for c#, for many cases you can replace if/else if/else with those. The pattern matching is very powerful too:

https://learn.microsoft.com/en-us/dotnet/csharp/language-ref...

"If/else expressions", as opposed to if/else merely doing control flow. Really surprising that they took so long to become mainstream, yet still more than a decade after I started using them I still occasionally miss the more "expression-like" look of the ternary in languages that don't offer both.

A predicate?

No, if, and match, and most things are expressions, and thus have a (typed) value.

In a typical programming language we can write something like x = 5; assigning 5 to the variable x. That 5 there is an expression, we can write x = (3 * 2) - 1; with the same effect, that's a more complicated expression. We can call a function here: x = f(3); or if our language has methods we can even call those: x = some.function(parameters);

In Rust I can write x = if it.should_be_nine() { 9 } else { 5 }; // because if is an expression

Since Rust's loops are also expressions, x = loop { let stuff = get_stuff(); if stuff.is_good() { break stuff } }; // ... once the stuff is good, break out of the loop and we'll assign that stuff to x

Understood, these things are expressions, but must they nit evaluate to a boolean in order for if/switch/match to branch correctly?

My informal understanding of a predicate may need refining.

I think the thing you're missing is that in some languages we're allowed to use these constructs as expressions. Not that they take expressions which is common in modern non-toy languages, but that they themselves are expressions.

It might be you've just always used languages where you can do this, or that you assumed you can but actually you never tried in a language you use.

In C for example we can't write this:

  int x = if (1 == 2) { 3 } else { 4 };  // Not valid C syntax

C provides a special operator, the only one in the language which has three operands and thus it's often just called "the ternary operator" although other ternary operators can technically exist, to achieve the same thing:

  int x = (1 == 2) ? 3 : 4;  // Valid C syntax using ternary operator

But, how about this?

  int x = switch 3 { case 1: 4; case 2: 8; default: 0; };   // Can't do this either

There's no way to express that in C or C++ today. The closest is the "Immediately Invoked Lambda" from C++ which is illustrated nearby in this thread. Barry Revzin apparently proposed a way to do this in C++ 26 because C++ wants to have pattern matching and pattern matching kinda sucks without this feature.

Apparently C++ 26 might get statement expressions in some form, it sounds like Barry Revzin sketched something at Issaquah (the recent WG21 meeting) which can do this.

you can do this in c++ as well with a lambda

  const value = [&]() {   
    if (a) {
      return true;
    }
    return switch (b) {
      case 1: return false;
      default: return undefinied;
    }
  }();

An immediately invoked lambda pattern, but, check out how ugly that was compared to:

  let value = if a { true } else { match b { 1 => false, _ => undefined } };

And notice that because now we're a function our relationship to the world changed, how does your immediately invoked lambda do this?

  let value = if a { true } else { match b { 1 => false, 2 => return foo, _ => undefined }};

With expression syntax returning from the function we're in is fine† but in your lambda you can't do that, you need control flow logic outside the lambda to handle it.

† You might wonder about the inferred type of this expression since it might return. The type of the return expression in Rust is ! aka Never, which is an empty type. In the same way that N + 0 == N in integer arithmetic, any type plus an empty type is the original type again in type arithmetic, so the type of the expression isn't altered.

Sure, in a lot of languages this is possible, but usually much slower, even slower than named functions. Can the c++ compiler in-line the lambda and remove the function call completely?

Still the syntax is a bit confusing. In ML languages (f# and also rust are somehow descendants of ML) you can just use if .. else if .. else expressions. They work like ternaries! But easier readable. Nested ternaries are useful, but get really hard to read very fast. (x = condition1 ? A : condition2 ? B : C;)

> Can the c++ compiler in-line the lambda and remove the function call completely?

LLVM and GCC can at least.

And indeed almost exactly like that in JavaScript - just substitute ()=> for the [&]()

You can’t directly call a function definition in js, so it will look like this:

  const value = (()=>{
    …
  })()

Reply on news.ycombinator.com