{-# LANGUAGE MagicHash #-}
{-# LANGUAGE UnboxedTuples #-}

module Data.Maybe.Unpacked.Numeric.Word128
  ( Maybe (..)
  , just
  , nothing
  , maybe
  , isJust
  , isNothing
  , fromMaybe
  , listToMaybe
  , maybeToList
  , catMaybes
  , mapMaybe
  , toBaseMaybe
  , fromBaseMaybe
  ) where

import Prelude hiding (Maybe, maybe)

import Data.WideWord (Word128 (..))
import GHC.Base (build)
import GHC.Exts (Word64#)
import GHC.Word (Word64 (W64#))

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 (# (# #) | (# Word64#, Word64# #) #)

instance Eq Maybe where
  Maybe
ma == :: Maybe -> Maybe -> Bool
== Maybe
mb =
    Bool -> (Word128 -> Bool) -> Maybe -> Bool
forall a. a -> (Word128 -> a) -> Maybe -> a
maybe
      (Maybe -> Bool
isNothing Maybe
mb)
      (\Word128
a -> Bool -> (Word128 -> Bool) -> Maybe -> Bool
forall a. a -> (Word128 -> a) -> Maybe -> a
maybe Bool
False (\Word128
b -> Word128
a Word128 -> Word128 -> Bool
forall a. Eq a => a -> a -> Bool
== Word128
b) Maybe
mb)
      Maybe
ma

instance Ord Maybe where
  compare :: Maybe -> Maybe -> Ordering
compare Maybe
ma Maybe
mb = Ordering -> (Word128 -> Ordering) -> Maybe -> Ordering
forall a. a -> (Word128 -> a) -> Maybe -> a
maybe Ordering
LT (\Word128
a -> Ordering -> (Word128 -> Ordering) -> Maybe -> Ordering
forall a. a -> (Word128 -> a) -> Maybe -> a
maybe Ordering
GT (Word128 -> Word128 -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Word128
a) Maybe
mb) Maybe
ma

instance Show Maybe where
  showsPrec :: Int -> Maybe -> ShowS
showsPrec Int
p (Maybe (# (# #) | (# Word64#, Word64# #) #)
m) = case (# (# #) | (# Word64#, Word64# #) #)
m of
    (# (# #) | #) -> String -> ShowS
showString String
"nothing"
    (# | (# Word64#
wa, Word64#
wb #) #) ->
      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 -> Word128 -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 (Word64 -> Word64 -> Word128
Word128 (Word64# -> Word64
W64# Word64#
wa) (Word64# -> Word64
W64# Word64#
wb))

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 = 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
"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
      Word128
a <- ReadPrec Word128 -> ReadPrec Word128
forall a. ReadPrec a -> ReadPrec a
step ReadPrec Word128
forall a. Read a => ReadPrec a
readPrec
      Maybe -> ReadPrec Maybe
forall a. a -> ReadPrec a
forall (m :: * -> *) a. Monad m => a -> m a
return (Word128 -> Maybe
just Word128
a)

listToMaybe :: [Word128] -> Maybe
listToMaybe :: [Word128] -> Maybe
listToMaybe [] = Maybe
nothing
listToMaybe (Word128
x : [Word128]
_) = Word128 -> Maybe
just Word128
x

maybeToList :: Maybe -> [Word128]
maybeToList :: Maybe -> [Word128]
maybeToList = [Word128] -> (Word128 -> [Word128]) -> Maybe -> [Word128]
forall a. a -> (Word128 -> a) -> Maybe -> a
maybe [] (Word128 -> [Word128] -> [Word128]
forall a. a -> [a] -> [a]
: [])

catMaybes :: [Maybe] -> [Word128]
catMaybes :: [Maybe] -> [Word128]
catMaybes = (Maybe -> Maybe) -> [Maybe] -> [Word128]
forall a. (a -> Maybe) -> [a] -> [Word128]
mapMaybe Maybe -> Maybe
forall a. a -> a
id

mapMaybe :: (a -> Maybe) -> [a] -> [Word128]
mapMaybe :: forall a. (a -> Maybe) -> [a] -> [Word128]
mapMaybe a -> Maybe
_ [] = []
mapMaybe a -> Maybe
f (a
a : [a]
as) =
  let ws :: [Word128]
ws = (a -> Maybe) -> [a] -> [Word128]
forall a. (a -> Maybe) -> [a] -> [Word128]
mapMaybe a -> Maybe
f [a]
as
   in [Word128] -> (Word128 -> [Word128]) -> Maybe -> [Word128]
forall a. a -> (Word128 -> a) -> Maybe -> a
maybe [Word128]
ws (Word128 -> [Word128] -> [Word128]
forall a. a -> [a] -> [a]
: [Word128]
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 :: (Word128 -> r -> r) -> (a -> Maybe) -> a -> r -> r
mapMaybeFB :: forall r a. (Word128 -> r -> r) -> (a -> Maybe) -> a -> r -> r
mapMaybeFB Word128 -> r -> r
cons a -> Maybe
f a
x r
next = r -> (Word128 -> r) -> Maybe -> r
forall a. a -> (Word128 -> a) -> Maybe -> a
maybe r
next ((Word128 -> r -> r) -> r -> Word128 -> r
forall a b c. (a -> b -> c) -> b -> a -> c
flip Word128 -> r -> r
cons r
next) (a -> Maybe
f a
x)

isNothing :: Maybe -> Bool
isNothing :: Maybe -> Bool
isNothing = Bool -> (Word128 -> Bool) -> Maybe -> Bool
forall a. a -> (Word128 -> a) -> Maybe -> a
maybe Bool
True (Bool -> Word128 -> Bool
forall a b. a -> b -> a
const Bool
False)

isJust :: Maybe -> Bool
isJust :: Maybe -> Bool
isJust = Bool -> (Word128 -> Bool) -> Maybe -> Bool
forall a. a -> (Word128 -> a) -> Maybe -> a
maybe Bool
False (Bool -> Word128 -> Bool
forall a b. a -> b -> a
const Bool
True)

nothing :: Maybe
nothing :: Maybe
nothing = (# (# #) | (# Word64#, Word64# #) #) -> Maybe
Maybe (# (# #) | #)

just :: Word128 -> Maybe
just :: Word128 -> Maybe
just (Word128 (W64# Word64#
wa) (W64# Word64#
wb)) = (# (# #) | (# Word64#, Word64# #) #) -> Maybe
Maybe (# | (# Word64#
wa, Word64#
wb #) #)

fromMaybe :: Word128 -> Maybe -> Word128
fromMaybe :: Word128 -> Maybe -> Word128
fromMaybe Word128
a (Maybe (# (# #) | (# Word64#, Word64# #) #)
m) = case (# (# #) | (# Word64#, Word64# #) #)
m of
  (# (# #) | #) -> Word128
a
  (# | (# Word64#
wa, Word64#
wb #) #) -> Word64 -> Word64 -> Word128
Word128 (Word64# -> Word64
W64# Word64#
wa) (Word64# -> Word64
W64# Word64#
wb)

maybe :: a -> (Word128 -> a) -> Maybe -> a
maybe :: forall a. a -> (Word128 -> a) -> Maybe -> a
maybe a
a Word128 -> a
f (Maybe (# (# #) | (# Word64#, Word64# #) #)
m) = case (# (# #) | (# Word64#, Word64# #) #)
m of
  (# (# #) | #) -> a
a
  (# | (# Word64#
wa, Word64#
wb #) #) -> Word128 -> a
f (Word64 -> Word64 -> Word128
Word128 (Word64# -> Word64
W64# Word64#
wa) (Word64# -> Word64
W64# Word64#
wb))

toBaseMaybe :: Maybe -> P.Maybe Word128
toBaseMaybe :: Maybe -> Maybe Word128
toBaseMaybe = Maybe Word128
-> (Word128 -> Maybe Word128) -> Maybe -> Maybe Word128
forall a. a -> (Word128 -> a) -> Maybe -> a
maybe Maybe Word128
forall a. Maybe a
P.Nothing Word128 -> Maybe Word128
forall a. a -> Maybe a
P.Just

fromBaseMaybe :: P.Maybe Word128 -> Maybe
fromBaseMaybe :: Maybe Word128 -> Maybe
fromBaseMaybe = Maybe -> (Word128 -> Maybe) -> Maybe Word128 -> Maybe
forall b a. b -> (a -> b) -> Maybe a -> b
P.maybe Maybe
nothing Word128 -> Maybe
just