Why should I use case expressions if I can use "equations"?

Question

I'm learning Haskell, from the book "Real World Haskell". In pages 66 and 67, they show the case expressions with this example:

fromMaybe defval wrapped =
    case wrapped of 
        Nothing    -> defval
        Just value -> value

I remember a similar thing in F#, but (as shown earlier in the book) Haskell can define functions as series of equations; while AFAIK, F Sharp cannot. So I tried to define this in such a way:

fromMaybe2 defval Nothing = defval
fromMaybe2 defval (Just value) = value

I loaded it in GHCi and after a couple of results, I convinced myself it was the same However; this makes me wonder, why should there be case expressions when equations:

• are more comprehensible (it's Mathematics; why use case something of, who says that?);
• are less verbose (2 vs 4 lines);
• require much less structuring and syntatic sugar (-> could be an operator, look what they've done!);
• only use variables when needed (in basic cases, such as this wrapped just takes up space).

What's good about case expressions? Do they exist only because similar FP-based languages (such as F#) have them? Am I missing something?

Edit:

I see from @freyrs's answer that the compiler makes these exactly the same. So, equations can always be turned into case expressions (as expected). My next question is the converse; can one go the opposite route of the compiler and use equations with let/where expressions to express any case expression?

Answer 1

This comes from a culture of having small "kernel" expression-oriented languages. Haskell grows from Lisp's roots (i.e. lambda calculus and combinatory logic); it's basically Lisp plus syntax plus explicit data type definitions plus pattern matching minus mutation plus lazy evaluation (lazy evaluation was itself first described in Lisp AFAIK; i.e. in the 70-s).

Lisp-like languages are expression-oriented, i.e. everything is an expression, and a language's semantics is given as a set of reduction rules, turning more complex expressions into simpler ones, and ultimately into "values".

Equations are not expressions. Several equations could be somehow mashed into one expression; you'd have to introduce some syntax for that; case is that syntax.

Rich syntax of Haskell gets translated into smaller "core" language, that has case as one of its basic building blocks. case has to be a basic construct, because pattern-matching in Haskell is made to be such a basic, core feature of the language.

---

To your new question, yes you can, by introducing auxiliary functions as Luis Casillas shows in his answer, or with the use of pattern guards, so his example becomes:

foo x y | (Meh o p) <- z = baz y p o
        | (Gah t q) <- z = quux x t q
    where 
       z = bar x