Shortening function definitions using multine patterns in haskell

Question

Is it better to do:

charToAction 'q' = Just $ WalkRight False
charToAction 'd' = Just $ WalkRight True
charToAction 'z' = Just Jump
charToAction _ = Nothing

or

charToAction x = case x of
    'q' -> Just $ WalkRight False
    'd' -> Just $ WalkRight True
    'z' -> Just Jump
    _ -> Nothing

?

Which one do you like better? There's no performance difference in either of these solutions. Just go with the one you personally like better in terms of syntax. — Sean Johnson
– Sean Johnson, Commented Jun 24, 2012 at 16:29
if, case, guards, pattern-matching, I'm torn apart by these! — L01man
– L01man, Commented Jun 24, 2012 at 16:52
if and guards aren't good options for this, but the two you're asking about are indeed equivalent – as a matter of fact, GHC will pack different patterns for a function in a case statement in the first compilation step anyway. — leftaroundabout
– leftaroundabout, Commented Jun 24, 2012 at 17:43

Cat Plus Plus · Accepted Answer · 2012-06-24 16:28:38Z

8

There's absolutely no functional difference whatsoever. It's a matter of personal preference.

answered Jun 24, 2012 at 16:28

Cat Plus Plus

131k27 gold badges205 silver badges226 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Edward Kmett Over a year ago

There is a alight difference when you have multiple arguments with regards to the willingness to back up and retry, but you can always desugar to the case statements, since that is what happens in ghc core. ;)

applicative · Accepted Answer · 2012-06-24 19:08:54Z

2

There is no performance difference because the first definition desugars to the second. You were right to prefer a case + pattern matching solution to one with guards and an equality test, some excellent general remarks are here: http://existentialtype.wordpress.com/2011/03/15/boolean-blindness/ (His examples are in ML but translate immediately to Haskell).

Note that you are misusing otherwise in the second definition; you should just write _ -> Nothing It isn't the otherwise of guards that you are using, you could as well have written fmap -> Nothing and the same would have happened.

answered Jun 24, 2012 at 19:08

applicative

8,23937 silver badges38 bronze badges

1 Comment

L01man Over a year ago

Thanks for the article! It's true booleans are very low-level and thus should be avoided when possible.

Gabriella Gonzalez · Accepted Answer · 2012-06-24 22:27:49Z

As others mentioned, there is no difference in the generated code as the former approach desugars to the latter approach, however I can point out some other considerations that may help you choose one or the other to use:

The former approach looks prettier in some circumstances (although I personally think that once you have lots of cases it is distracting)
The former approach makes it slightly more difficult to refactor the name. Using the case statement the name of the function only appears once.
Case statements can be used anywhere in your code and can be used anonymously. The former approach requires using a let or where block to define pattern-matching functions within a function.

However, there are no cases where you can't translate one into the other. It's entirely a matter of coding style.

Collectives™ on Stack Overflow

Shortening function definitions using multine patterns in haskell

3 Answers 3

1 Comment

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

1 Comment

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related