How do I make a switch case in cppfront?

[MatthieuHernandez]

I couldn't find anything about this in the documentation. I tried to use an inspect instead but it seems impossible for the moment:
error: an inspect expression alternative must be just an expression (not a braced block).

[JohelEGP]

Here's an example, from the documentation's inspect — pattern match.

//  A generic function that takes an argument 'x' of any type
//  and inspects various things about `x`
test: (x) = {
    forty_two := 42;
    std::cout
        << inspect x -> std::string {
            is 0           = "zero";            // == 0
            is (forty_two) = "the answer";      // == 42
            is int         = "integer";         // is type int (and not 0 or 42)
            is std::string = x as std::string;  // is type std::string
            is std::vector = "a std::vector";   // is a vector</*of-some-type*/>
            is _           = "(no match)";      // is something else
        }
        << "\n";
}

//  Sample call site
test(42);
    //  Behaves as if the following function were called:
    //      test: (x) = { std::cout << (:std::string = "the answer") << "\n"; }
    //  (and that's why inspect alternatives are introduced with '=')

[JohelEGP]

And here it is compilable: https://cpp2.godbolt.org/z/P3n9Kfxjz.

[MatthieuHernandez]

Yes, I know that, but how do you execute a lambda in an inspect?
How can I do something like this?

printMenu();
selection: int = getInputMenu();
exit = inspect selection -> bool {
    is 1 = {
        foo();
        return false;
    };
    is 2 = {
        std::cout << "bye" << std::endl;
        return true;
    };
    is _ = false;
};

[JohelEGP]

With an IIFE (https://cpp2.godbolt.org/z/89YaGjMoP):

            is 0           = :() -> _ = {
                                std::cout << "was 0!\n";
                                return "zero";
                              }();            // == 0

[hsutter]

Cppfront doesn't yet support blocks in inspect alternatives. For now this will work:

exit = inspect selection -> bool {
    is 1 = :()->bool={
        foo();
        return false;
    }();
    is 2 = :()->bool={
        std::cout << "bye" << std::endl;
        return false;
    }();
    is _ = false;
};

To my surprise, one thing I've learned so far with cppfront is that inspect doesn't appear to be one of the popular features. Most other features have generated a lot of usability/correctness feedback like this, and I originally expected much more of that for inspect but inspect has been generally quiet. That usually indicates that people aren't trying to use a feature...? And that could be useful information about the relative importance of standardizing inspect in ISO C++...

[MatthieuHernandez]

I think the syntax is too complicated compared to its C++ equivalent:

switch (selection) {
    case 1:
        foo();
        break;
    case 2:
        std::cout << "bye" << std::endl;
        exit = true;
        break;
    default:
       std::cout << "Invalid selection." << std::endl;
    }

However, it works well. Thanks for your time 😊

[DyXel]

I haven't really used inspect because I don't think is powerful enough to be used. Here's a list of stuff I had written down for which I planned to open a separate discussion, but might as well hijack in here:

• There's no way to write regular structured code without the involvements of lots of lambdas as described in other comments
• Tying to the above, you can't have regular "switch-looking" inspect, I'd expect the following to work:

inspect some_char {
  is 'a' = { std::cout << "The first letter of the Latin alphabet"; }
  is 'b' = { std::cout << "The last letter of the Latin alphabet"; }
  is _ = { std::cout << "Some other character"; }
};
// or instead, same as function bodies, to be able to use _ = std::cout << "blah blah";

• No fallthrough, how do you make your Duff's device? This combined with no way to match multiple things to a block statement makes it harder to use effectively.
• It's hard to go from a series of if statements to inspect

Good thing its got going:

• You can (ab)use it as a makeshift ternary expression.

But really, I feel like if statements, inspect expressions and ternary operations should be closely knitted, they are all part of control flow and upgrading/changing code from one to the other should be easier. It feels like inspect needs more polish to be as strong as other language's pattern matching implementations, subsume all the usecases of old switch and so that it feels like it belongs with the rest of the features of the language. Unfortunately I don't have specific design directions to propose, sorry about that.

[ntrel]

No fallthrough, how do you make your Duff's device?

We'd need some kind of statement to indicate a 'jump' to the next case (even though it would be a no-op for that). D has goto case; for this (and also e.g. goto case 5;, goto default;) - https://dlang.org/spec/statement.html#goto-statement.

[JohelEGP]

Gripes with inspect are better off as standalone replies for more visibility.

• This combined with no way to match multiple things to a block statement makes it harder to use effectively.

Like in x is (in(10, 20)),
you can have a predicate like any_of('a', 'b').

[DyXel]

yes, I am aware that you can use expressions or inline lambdas like that to match multiple things, but for such a common case (match multiple things to the same logic), it probably should have a clearer way of doing directly. I feel like inspect is on the verge of greatness, it just needs a little extra push and polish.

[JohelEGP]

The paper (see https://github.com/hsutter/cppfront?tab=readme-ov-file#2021-is-as-and-pattern-matching)
has things like that starting at §3.3.

[DyXel]

Oh yeah, the paper definitely supports many more things like de-structuring, nesting and switch-like expressions. So yeah, I think if these remaining things were implemented, the feature would be in a much better spot. At the moment its just more cost-effective to just write long if-else chains 😛