Hacker News Reader

Comment by yiransheng | Hacker News Reader

In languages like Haskell and Scala that supports `do` / `for` comprehension sugar, this could be done without the nesting:

  fn :: Maybe Int -> Maybe Int -> Int
  fn q z = fromMaybe 0 $
    do 
      q_in <- q
      z_in <- z
      return (q_in + z_in)

In modern Haskell, we are more likely to use the Applicative instance for Maybe, e.g.

    fromMaybe 0 $ 
        (+) <$> xm <*> ym

Or just:

    fn (Just q) (Just z) = q + z
    fn _ _ = 0

Wouldn't this let me call `fn true false` or `fn "hi" 2`? Or the second declaration takes the inferred type of the arguments from the first one?

This isn't two functions: it's actually one function defined by cases. You can think of it as equivalent to

    fn x y = case (x, y) of
      (Just q, Just z) -> q + z
      (_, _) -> 0

but the case becomes implicit in the repetition of the function name at the top level of indentation.

> at the top level of indentation

At the same level, really - it works in a let or a where as well.

Surely since you have monads you can just use the tools they give you?

    fn = liftM2 (+)

That doesn't do quite the same thing; the original example gets rid of the Maybe, defaulting to 0.

> That doesn't do quite the same thing

You're missing the point entirely.

> the original example gets rid of the Maybe, defaulting to 0.