Safe Haskell | Safe-Inferred |
---|
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
- fromMaybe :: (Generic maybe, MaybeLike (Rep maybe) a) => a -> maybe -> a
- maybe :: (Generic maybe, MaybeLike (Rep maybe) a) => b -> (a -> b) -> maybe -> b
- isJust :: forall maybe a. (Generic maybe, MaybeLike (Rep maybe) a) => maybe -> Bool
- isNothing :: forall maybe a. (Generic maybe, MaybeLike (Rep maybe) a) => maybe -> Bool
- fromJust :: (Generic maybe, MaybeLike (Rep maybe) a) => maybe -> a
- listToMaybe :: (Generic maybe, MaybeLike (Rep maybe) a) => [a] -> maybe
- maybeToList :: (Generic maybe, MaybeLike (Rep maybe) a) => maybe -> [a]
- catMaybes :: (Generic maybe, MaybeLike (Rep maybe) a) => [maybe] -> [a]
- mapMaybe :: (Generic maybe, MaybeLike (Rep maybe) b) => (a -> maybe) -> [a] -> [b]
- convert :: (Generic maybe1, MaybeLike (Rep maybe1) a, Generic maybe2, MaybeLike (Rep maybe2) a) => maybe1 -> maybe2
- class MaybeLike rep any | rep -> any
Data.Maybe Functions
fromMaybe :: (Generic maybe, MaybeLike (Rep maybe) a) => a -> maybe -> aSource
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 -> bSource
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 -> BoolSource
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 -> BoolSource
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 -> aSource
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] -> maybeSource
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]Source
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]Source
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]Source
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 -> maybe2Source
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 -> anySource
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.