Data.Generics.Maybe

This module is a drop in replacement for Maybe. It generalizes the functions to any types that share the same "sum of products" view of Maybe.

To use the module for your type, enable GHC's DeriveGeneric extension and derive a Generic instance for your type.

import GHC.Generics

data Result a = Success a | Fail
   deriving (Show, Generic)

data Nat = Zero | Succ Nat
   deriving (Show, Generic)

After which you can use the function, like your type was Maybe

Data.Maybe Functions

fromMaybe :: (Generic maybe, MaybeLike (Rep maybe) a) => a -> maybe -> a

A generalized version of fromMaybe

 fromMaybe :: a -> Maybe a -> Maybe a

>>> fromMaybe 'a' Nothing
'a'

>>> fromMaybe 'a' $ Just 'b'
'b'

>>> fromMaybe 'a' Fail
'a'

>>> fromMaybe 'a' $ Success 'b'
'b'

>>> fromMaybe Zero Zero
Zero

>>> fromMaybe Zero $ Succ (Succ Zero)
Succ Zero

maybe :: (Generic maybe, MaybeLike (Rep maybe) a) => b -> (a -> b) -> maybe -> b

A generalized version of maybe

 maybe :: b -> (a -> b) -> Maybe a -> Maybe b

>>> maybe (1 :: Int) (+1) Nothing
1

>>> maybe 1 (+1) $ Just 1
2

>>> maybe (1 :: Int) (+1) Fail
1

>>> maybe 1 (+1) $ Success 1
2

>>> maybe (Succ Zero) Succ Zero
Succ Zero

>>> maybe (Succ Zero) Succ $ Succ (Succ Zero)
Succ (Succ Zero)

isJust :: forall maybe a. (Generic maybe, MaybeLike (Rep maybe) a) => maybe -> Bool

A generalized version of isJust

 isJust :: Maybe a -> Bool

>>> isJust Nothing
False

>>> isJust $ Just 'a'
True

>>> isJust Fail
False

>>> isJust $ Success 'a'
True

>>> isJust Zero
False

>>> isJust $ Succ Zero
True

isNothing :: forall maybe a. (Generic maybe, MaybeLike (Rep maybe) a) => maybe -> Bool

A generalized version of isNothing

 isNothing :: Maybe a -> Bool

>>> isNothing Nothing
True

>>> isNothing $ Just 'a'
False

>>> isNothing Fail
True

>>> isNothing $ Success 'a'
False

>>> isNothing Zero
True

>>> isNothing $ Succ Zero
False

fromJust :: (Generic maybe, MaybeLike (Rep maybe) a) => maybe -> a

A generalized version of fromJust

 fromJust :: Maybe a -> a

>>> fromJust Nothing
*** Exception: Generics.fromJust. You shouldn't really use this.

>>> fromJust $ Just 'a'
'a'

>>> fromJust Fail
*** Exception: Generics.fromJust. You shouldn't really use this.

>>> fromJust $ Success 'a'
'a'

>>> fromJust Zero
*** Exception: Generics.fromJust. You shouldn't really use this.

>>> fromJust $ Succ Zero
Zero

listToMaybe :: (Generic maybe, MaybeLike (Rep maybe) a) => [a] -> maybe

A generalized version of listToMaybe

 listToMaybe :: [a] -> Maybe a

>>> listToMaybe ['a', 'b'] :: Maybe Char
Just 'a'

>>> listToMaybe [] :: Maybe Char
Nothing

>>> listToMaybe ['a', 'b'] :: Result Char
Success 'a'

>>> listToMaybe [] :: Result Char
Fail

>>> listToMaybe [Zero, Succ Zero] :: Nat
Succ Zero

>>> listToMaybe [] :: Nat
Zero

maybeToList :: (Generic maybe, MaybeLike (Rep maybe) a) => maybe -> [a]

A generalized version of maybeToList

 maybeToList :: Maybe a -> [a]

>>> maybeToList $ Just True
[True]

>>> maybeToList Nothing
[]

>>> maybeToList $ Success True
[True]

>>> maybeToList Fail
[]

>>> maybeToList $ Succ Zero
[Zero]

>>> maybeToList Zero
[]

catMaybes :: (Generic maybe, MaybeLike (Rep maybe) a) => [maybe] -> [a]

A generalized version of catMaybes

 catMaybes :: [Maybe a] -> [a]

>>> catMaybes [Just True, Nothing, Just False]
[True,False]

>>> catMaybes [Success True, Fail, Success False]
[True,False]

>>> catMaybes [Succ Zero, Zero, Succ Zero]
[Zero,Zero]

mapMaybe :: (Generic maybe, MaybeLike (Rep maybe) b) => (a -> maybe) -> [a] -> [b]

A generalized version of mapMaybe

 mapMaybe :: (a -> Maybe b) -> [a] -> [b]

>>> mapMaybe (\x -> if x then Just "True" else Nothing) [True, False, True]
["True","True"]

>>> mapMaybe (\x -> if x then Success "True" else Fail) [True, False, True]
["True","True"]

>>> mapMaybe (\x -> if x then Succ Zero else Zero) [True, False, True]
[Zero,Zero]

Convert between Maybelikes

convert :: (Generic maybe1, MaybeLike (Rep maybe1) a, Generic maybe2, MaybeLike (Rep maybe2) a) => maybe1 -> maybe2

Convert between two Maybelikes

>>> convert (Just 'a') :: Result Char
Success 'a'

>>> convert (Success 'a') :: Maybe Char
Just 'a'

>>> convert (Success Zero) :: Nat
Succ Zero

Exported for groking, but not for implementing.

class MaybeLike rep any | rep -> any

This type class is used to swap the order of constructors so unit shows up first.

 (M1 m a (C1 b (S1 e (Rec0 any)) :+: C1 y U1)) 

will become

 (M1 m a (C1 y U1 :+: C1 b (S1 e (Rec0 any))))

and

 (M1 m a (C1 y U1 :+: C1 b (S1 e (Rec0 any))))

is unchanged

Thus, there are only two instances and should only be, forever and always ... I think.

Instances

MaybeLike (M1 m a (:+: (C1 b (S1 e (K1 k any))) (C1 y U1))) any

MaybeLike (M1 m a (:+: (C1 y U1) (C1 b (S1 e (K1 k any))))) any