Mapping a functor to another in Haskell

Question

I have a function that produces a Maybe a type and I'm using it in a function to produce an Either b a. Is there a way I can map Nothing to Left x to simplify my code? The following code gives some context:

rmX :: ... -> Maybe a
cvX :: ... -> Either CVXError a
data CVXError = BadIndex | NoCover | NoSpace
cvX ... =
  ...
  case rmx 1 xs of
    Nothing -> Left NoSpace
    Just p  -> Right (x2:x1:(fromJust (rmX (-1) p)))
-- given that rmX always passes on negative value arg

The case statement is just begging to be replaced with fmap but the problem is that I'm not sure how to 'map' Nothing to Left NoSpace in an fmap call or to even extract this pattern to make my own util function.

Sebastian Redl · Accepted Answer · 2016-12-05 09:11:44Z

6

You're looking for the maybe function:

cvX ... =
  ...
  maybe (Left NoSpace) (\p -> Right (x2:x1:(fromJust (rmX (-1) p)))) $
    rmX 1 xs

answered Dec 5, 2016 at 9:11

Sebastian Redl

73.9k8 gold badges137 silver badges177 bronze badges

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

Comments

duplode · Accepted Answer · 2016-12-05 10:19:34Z

4

In this context, it is worth mentioning the errors package. It offers a number of functions for juggling Maybe, Either and related types, including note, which "[tags] the Nothing value of a Maybe":

note :: a -> Maybe b -> Either a b

cvX ... =
  ...
  note NoSpace $ fmap (\p -> x2:x1:(fromJust (rmX (-1) p))) (rmX 1 xs)

Unsurprisingly, the implementation of note uses maybe exactly like Sebastian Redl's answer does.

P.S.: It is always a little unpleasant to use fromJust, given how it fails when given Nothing. If rmX (-1) cannot produce a Nothing, you might want to consider factoring out a separate function that doesn't return Maybe a to be used instead of fromJust (rmX (-1) p).

edited Dec 5, 2016 at 10:19

answered Dec 5, 2016 at 10:06

duplode

34.5k7 gold badges88 silver badges160 bronze badges

Comments

chepner · Accepted Answer · 2016-12-05 15:56:51Z

0

One similar option is to use the Maybe monad until the very end, then apply Left or Right as necessary with maybe.

maybe (Left NoSpace) Right $ do
     p1 <- rmX 1 xs
     p2 <- rmX (-1) p1
     return (x2:x1:p2)

There's lots of room for tweaking this, depending on your preference for do notation vs >>=:

-- untested; take these with a grain of salt...

maybe (Left NoSpace) Right $ do
    p <- rmX 1 xs >>= rmX (-1) 
    return (x2:x1:p)

maybe (Left NoSpace) Right (rmX 1 xs >>= rmX (-1) >>= (return . (x1:)) >>= (return . (x2:)))

-- etc

edited Dec 5, 2016 at 15:56

answered Dec 5, 2016 at 15:07

chepner

538k77 gold badges594 silver badges746 bronze badges

Collectives™ on Stack Overflow

Mapping a functor to another in Haskell

3 Answers 3

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related