{-# LANGUAGE MagicHash #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE UnboxedTuples #-}
{-# LANGUAGE ViewPatterns #-}
module Data.Maybe.Unpacked.Numeric.Word32
( Maybe (..)
, just
, nothing
, maybe
, isJust
, isNothing
, fromMaybe
, listToMaybe
, maybeToList
, catMaybes
, mapMaybe
, toBaseMaybe
, fromBaseMaybe
, pattern Nothing
, pattern Just
) where
import Prelude hiding (Just, Maybe, Nothing, maybe)
import GHC.Base (build)
import GHC.Exts (Word#)
import GHC.Word (Word32)
import GHC.Word.Compat (pattern W32#)
import GHC.Read (Read (readPrec))
import Text.ParserCombinators.ReadPrec (prec, step)
import Text.Read (Lexeme (Ident), lexP, parens, (+++))
import qualified Prelude as P
data Maybe = Maybe (# (# #) | Word# #)
pattern Nothing :: Maybe
pattern $mNothing :: forall {r}. Maybe -> ((# #) -> r) -> ((# #) -> r) -> r
$bNothing :: Maybe
Nothing = Maybe (# (# #) | #)
pattern Just :: Word32 -> Maybe
pattern $mJust :: forall {r}. Maybe -> (Word32 -> r) -> ((# #) -> r) -> r
$bJust :: Word32 -> Maybe
Just i <- Maybe (# | (W32# -> i) #)
where
Just (W32# Word#
i) = (# (# #) | Word# #) -> Maybe
Maybe (# | Word#
i #)
{-# COMPLETE Nothing, Just #-}
instance Eq Maybe where
Maybe
ma == :: Maybe -> Maybe -> Bool
== Maybe
mb =
Bool -> (Word32 -> Bool) -> Maybe -> Bool
forall a. a -> (Word32 -> a) -> Maybe -> a
maybe
(Maybe -> Bool
isNothing Maybe
mb)
(\Word32
a -> Bool -> (Word32 -> Bool) -> Maybe -> Bool
forall a. a -> (Word32 -> a) -> Maybe -> a
maybe Bool
False (\Word32
b -> Word32
a Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
b) Maybe
mb)
Maybe
ma
instance Ord Maybe where
compare :: Maybe -> Maybe -> Ordering
compare Maybe
ma Maybe
mb = case Maybe
ma of
Just Word32
a -> case Maybe
mb of
Just Word32
b -> Word32 -> Word32 -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Word32
a Word32
b
Maybe
_ -> Ordering
GT
Maybe
_ -> case Maybe
mb of
Just{} -> Ordering
LT
Maybe
_ -> Ordering
EQ
instance Show Maybe where
showsPrec :: Int -> Maybe -> ShowS
showsPrec Int
p (Maybe (# (# #) | Word# #)
m) = case (# (# #) | Word# #)
m of
(# (# #) | #) -> String -> ShowS
showString String
"nothing"
(# | Word#
w #) ->
Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
String -> ShowS
showString String
"just "
ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Word32 -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 (Word# -> Word32
W32# Word#
w)
instance Read Maybe where
readPrec :: ReadPrec Maybe
readPrec = ReadPrec Maybe -> ReadPrec Maybe
forall a. ReadPrec a -> ReadPrec a
parens (ReadPrec Maybe -> ReadPrec Maybe)
-> ReadPrec Maybe -> ReadPrec Maybe
forall a b. (a -> b) -> a -> b
$ ReadPrec Maybe
nothingP ReadPrec Maybe -> ReadPrec Maybe -> ReadPrec Maybe
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++ ReadPrec Maybe
justP
where
nothingP :: ReadPrec Maybe
nothingP = do
Ident String
"nothing" <- ReadPrec Lexeme
lexP
Maybe -> ReadPrec Maybe
forall a. a -> ReadPrec a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe
nothing
justP :: ReadPrec Maybe
justP = Int -> ReadPrec Maybe -> ReadPrec Maybe
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
10 (ReadPrec Maybe -> ReadPrec Maybe)
-> ReadPrec Maybe -> ReadPrec Maybe
forall a b. (a -> b) -> a -> b
$ do
Ident String
"just" <- ReadPrec Lexeme
lexP
Word32
a <- ReadPrec Word32 -> ReadPrec Word32
forall a. ReadPrec a -> ReadPrec a
step ReadPrec Word32
forall a. Read a => ReadPrec a
readPrec
Maybe -> ReadPrec Maybe
forall a. a -> ReadPrec a
forall (m :: * -> *) a. Monad m => a -> m a
return (Word32 -> Maybe
just Word32
a)
listToMaybe :: [Word32] -> Maybe
listToMaybe :: [Word32] -> Maybe
listToMaybe [] = Maybe
nothing
listToMaybe (Word32
x : [Word32]
_) = Word32 -> Maybe
just Word32
x
maybeToList :: Maybe -> [Word32]
maybeToList :: Maybe -> [Word32]
maybeToList = [Word32] -> (Word32 -> [Word32]) -> Maybe -> [Word32]
forall a. a -> (Word32 -> a) -> Maybe -> a
maybe [] (Word32 -> [Word32] -> [Word32]
forall a. a -> [a] -> [a]
: [])
catMaybes :: [Maybe] -> [Word32]
catMaybes :: [Maybe] -> [Word32]
catMaybes = (Maybe -> Maybe) -> [Maybe] -> [Word32]
forall a. (a -> Maybe) -> [a] -> [Word32]
mapMaybe Maybe -> Maybe
forall a. a -> a
id
mapMaybe :: (a -> Maybe) -> [a] -> [Word32]
mapMaybe :: forall a. (a -> Maybe) -> [a] -> [Word32]
mapMaybe a -> Maybe
_ [] = []
mapMaybe a -> Maybe
f (a
a : [a]
as) =
let ws :: [Word32]
ws = (a -> Maybe) -> [a] -> [Word32]
forall a. (a -> Maybe) -> [a] -> [Word32]
mapMaybe a -> Maybe
f [a]
as
in [Word32] -> (Word32 -> [Word32]) -> Maybe -> [Word32]
forall a. a -> (Word32 -> a) -> Maybe -> a
maybe [Word32]
ws (Word32 -> [Word32] -> [Word32]
forall a. a -> [a] -> [a]
: [Word32]
ws) (a -> Maybe
f a
a)
{-# NOINLINE [1] mapMaybe #-}
{-# RULES
"mapMaybe" [~1] forall f xs.
mapMaybe f xs =
build (\c n -> foldr (mapMaybeFB c f) n xs)
"mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f
#-}
{-# NOINLINE [0] mapMaybeFB #-}
mapMaybeFB :: (Word32 -> r -> r) -> (a -> Maybe) -> a -> r -> r
mapMaybeFB :: forall r a. (Word32 -> r -> r) -> (a -> Maybe) -> a -> r -> r
mapMaybeFB Word32 -> r -> r
cons a -> Maybe
f a
x r
next = r -> (Word32 -> r) -> Maybe -> r
forall a. a -> (Word32 -> a) -> Maybe -> a
maybe r
next ((Word32 -> r -> r) -> r -> Word32 -> r
forall a b c. (a -> b -> c) -> b -> a -> c
flip Word32 -> r -> r
cons r
next) (a -> Maybe
f a
x)
isNothing :: Maybe -> Bool
isNothing :: Maybe -> Bool
isNothing = Bool -> (Word32 -> Bool) -> Maybe -> Bool
forall a. a -> (Word32 -> a) -> Maybe -> a
maybe Bool
True (Bool -> Word32 -> Bool
forall a b. a -> b -> a
const Bool
False)
isJust :: Maybe -> Bool
isJust :: Maybe -> Bool
isJust = Bool -> (Word32 -> Bool) -> Maybe -> Bool
forall a. a -> (Word32 -> a) -> Maybe -> a
maybe Bool
False (Bool -> Word32 -> Bool
forall a b. a -> b -> a
const Bool
True)
nothing :: Maybe
nothing :: Maybe
nothing = (# (# #) | Word# #) -> Maybe
Maybe (# (# #) | #)
just :: Word32 -> Maybe
just :: Word32 -> Maybe
just (W32# Word#
w) = (# (# #) | Word# #) -> Maybe
Maybe (# | Word#
w #)
fromMaybe :: Word32 -> Maybe -> Word32
fromMaybe :: Word32 -> Maybe -> Word32
fromMaybe Word32
a (Maybe (# (# #) | Word# #)
m) = case (# (# #) | Word# #)
m of
(# (# #) | #) -> Word32
a
(# | Word#
w #) -> Word# -> Word32
W32# Word#
w
maybe :: a -> (Word32 -> a) -> Maybe -> a
maybe :: forall a. a -> (Word32 -> a) -> Maybe -> a
maybe a
a Word32 -> a
f (Maybe (# (# #) | Word# #)
m) = case (# (# #) | Word# #)
m of
(# (# #) | #) -> a
a
(# | Word#
w #) -> Word32 -> a
f (Word# -> Word32
W32# Word#
w)
toBaseMaybe :: Maybe -> P.Maybe Word32
toBaseMaybe :: Maybe -> Maybe Word32
toBaseMaybe = Maybe Word32 -> (Word32 -> Maybe Word32) -> Maybe -> Maybe Word32
forall a. a -> (Word32 -> a) -> Maybe -> a
maybe Maybe Word32
forall a. Maybe a
P.Nothing Word32 -> Maybe Word32
forall a. a -> Maybe a
P.Just
fromBaseMaybe :: P.Maybe Word32 -> Maybe
fromBaseMaybe :: Maybe Word32 -> Maybe
fromBaseMaybe = Maybe -> (Word32 -> Maybe) -> Maybe Word32 -> Maybe
forall b a. b -> (a -> b) -> Maybe a -> b
P.maybe Maybe
nothing Word32 -> Maybe
just