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 you 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

Documentation

type MaybeLike maybe a d u m b y = (Generic maybe, GMaybeLike (Rep maybe) (G d u m b y a))

A constraint synonym to make the type signatures look better. The 'd u m b y' type variables can be ignored.

fromMaybe :: MaybeLike maybe a d u m b y => 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 :: MaybeLike maybe a d u m b' y => 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 :: MaybeLike maybe a d u m b y => 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 :: MaybeLike maybe a d u m b y => 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 :: MaybeLike maybe a d u m b y => 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 :: MaybeLike maybe a d u m b y => [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 :: MaybeLike maybe a d u m b y => 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 :: MaybeLike maybe a d u m b y => [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 :: MaybeLike maybe a' d u m b y => (a -> maybe) -> [a] -> [a']

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]

Exported for groking, but not for implementing.

class GMaybeLike f g | f -> g

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

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

GMaybeLike (G m a y b e any) (G m a y b e any)

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

A silly type synonym to make the signatures look better. None of the type variables matter except any. Read Generic maybe