{-# LANGUAGE MultiWayIf #-}
{-# LANGUAGE ViewPatterns #-}
{-# LANGUAGE Strict #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE TypeApplications #-}
module Data.RLE.Internal where
import Control.Monad as CM
import Control.Monad.ST as CMST
import Control.Monad.State.Strict()
import Data.ByteString as BS
import Data.ByteString.Char8 as BSC8 (pack,unpack)
import Data.ByteString.Internal()
import Data.List()
import Data.Maybe as DMaybe (fromJust,isJust,isNothing)
import Data.STRef as DSTR
import Data.Text as DText
import Data.Vector as DVB
import Data.Vector.Unboxed()
import GHC.Generics (Generic)
import Prelude as P
newtype RLEB = RLEB (DVB.Vector (Maybe ByteString))
deriving (RLEB -> RLEB -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RLEB -> RLEB -> Bool
$c/= :: RLEB -> RLEB -> Bool
== :: RLEB -> RLEB -> Bool
$c== :: RLEB -> RLEB -> Bool
Eq,Eq RLEB
RLEB -> RLEB -> Bool
RLEB -> RLEB -> Ordering
RLEB -> RLEB -> RLEB
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: RLEB -> RLEB -> RLEB
$cmin :: RLEB -> RLEB -> RLEB
max :: RLEB -> RLEB -> RLEB
$cmax :: RLEB -> RLEB -> RLEB
>= :: RLEB -> RLEB -> Bool
$c>= :: RLEB -> RLEB -> Bool
> :: RLEB -> RLEB -> Bool
$c> :: RLEB -> RLEB -> Bool
<= :: RLEB -> RLEB -> Bool
$c<= :: RLEB -> RLEB -> Bool
< :: RLEB -> RLEB -> Bool
$c< :: RLEB -> RLEB -> Bool
compare :: RLEB -> RLEB -> Ordering
$ccompare :: RLEB -> RLEB -> Ordering
Ord,Int -> RLEB -> ShowS
[RLEB] -> ShowS
RLEB -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RLEB] -> ShowS
$cshowList :: [RLEB] -> ShowS
show :: RLEB -> String
$cshow :: RLEB -> String
showsPrec :: Int -> RLEB -> ShowS
$cshowsPrec :: Int -> RLEB -> ShowS
Show,ReadPrec [RLEB]
ReadPrec RLEB
Int -> ReadS RLEB
ReadS [RLEB]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RLEB]
$creadListPrec :: ReadPrec [RLEB]
readPrec :: ReadPrec RLEB
$creadPrec :: ReadPrec RLEB
readList :: ReadS [RLEB]
$creadList :: ReadS [RLEB]
readsPrec :: Int -> ReadS RLEB
$creadsPrec :: Int -> ReadS RLEB
Read,forall x. Rep RLEB x -> RLEB
forall x. RLEB -> Rep RLEB x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RLEB x -> RLEB
$cfrom :: forall x. RLEB -> Rep RLEB x
Generic)
newtype RLET = RLET (DVB.Vector (Maybe Text))
deriving (RLET -> RLET -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RLET -> RLET -> Bool
$c/= :: RLET -> RLET -> Bool
== :: RLET -> RLET -> Bool
$c== :: RLET -> RLET -> Bool
Eq,Eq RLET
RLET -> RLET -> Bool
RLET -> RLET -> Ordering
RLET -> RLET -> RLET
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: RLET -> RLET -> RLET
$cmin :: RLET -> RLET -> RLET
max :: RLET -> RLET -> RLET
$cmax :: RLET -> RLET -> RLET
>= :: RLET -> RLET -> Bool
$c>= :: RLET -> RLET -> Bool
> :: RLET -> RLET -> Bool
$c> :: RLET -> RLET -> Bool
<= :: RLET -> RLET -> Bool
$c<= :: RLET -> RLET -> Bool
< :: RLET -> RLET -> Bool
$c< :: RLET -> RLET -> Bool
compare :: RLET -> RLET -> Ordering
$ccompare :: RLET -> RLET -> Ordering
Ord,Int -> RLET -> ShowS
[RLET] -> ShowS
RLET -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RLET] -> ShowS
$cshowList :: [RLET] -> ShowS
show :: RLET -> String
$cshow :: RLET -> String
showsPrec :: Int -> RLET -> ShowS
$cshowsPrec :: Int -> RLET -> ShowS
Show,ReadPrec [RLET]
ReadPrec RLET
Int -> ReadS RLET
ReadS [RLET]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RLET]
$creadListPrec :: ReadPrec [RLET]
readPrec :: ReadPrec RLET
$creadPrec :: ReadPrec RLET
readList :: ReadS [RLET]
$creadList :: ReadS [RLET]
readsPrec :: Int -> ReadS RLET
$creadsPrec :: Int -> ReadS RLET
Read,forall x. Rep RLET x -> RLET
forall x. RLET -> Rep RLET x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RLET x -> RLET
$cfrom :: forall x. RLET -> Rep RLET x
Generic)
type RLEVecB = DVB.Vector (Maybe ByteString)
type STRLEVecB s a = STRef s RLEVecB
pushSTRLEVecB :: STRLEVecB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
pushSTRLEVecB :: forall s.
STRLEVecB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
pushSTRLEVecB STRLEVecB s (Maybe ByteString)
s Maybe ByteString
Nothing = do
Vector (Maybe ByteString)
s2 <- forall s a. STRef s a -> ST s a
readSTRef STRLEVecB s (Maybe ByteString)
s
forall s a. STRef s a -> a -> ST s ()
writeSTRef STRLEVecB s (Maybe ByteString)
s (forall a. Vector a -> a -> Vector a
DVB.snoc Vector (Maybe ByteString)
s2 forall a. Maybe a
Nothing)
pushSTRLEVecB STRLEVecB s (Maybe ByteString)
s (Just ByteString
e) = do
Vector (Maybe ByteString)
s2 <- forall s a. STRef s a -> ST s a
readSTRef STRLEVecB s (Maybe ByteString)
s
forall s a. STRef s a -> a -> ST s ()
writeSTRef STRLEVecB s (Maybe ByteString)
s (forall a. Vector a -> a -> Vector a
DVB.snoc Vector (Maybe ByteString)
s2 (forall a. a -> Maybe a
Just ByteString
e))
emptySTRLEVecB :: ST s (STRLEVecB s a)
emptySTRLEVecB :: forall s a. ST s (STRLEVecB s a)
emptySTRLEVecB = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Vector a
DVB.empty
type STRLETempB s a = STRef s (Maybe ByteString)
updateSTRLETempB :: STRLETempB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
updateSTRLETempB :: forall s.
STRLETempB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
updateSTRLETempB STRLETempB s (Maybe ByteString)
s Maybe ByteString
Nothing = forall s a. STRef s a -> a -> ST s ()
writeSTRef STRLETempB s (Maybe ByteString)
s forall a. Maybe a
Nothing
updateSTRLETempB STRLETempB s (Maybe ByteString)
s (Just ByteString
e) = forall s a. STRef s a -> a -> ST s ()
writeSTRef STRLETempB s (Maybe ByteString)
s (forall a. a -> Maybe a
Just ByteString
e)
emptySTRLETempB :: ST s (STRLETempB s a)
emptySTRLETempB :: forall s a. ST s (STRLETempB s a)
emptySTRLETempB = forall a s. a -> ST s (STRef s a)
newSTRef (forall a. a -> Maybe a
Just ByteString
BS.empty)
type STRLECounterB s a = STRef s Int
updateSTRLECounterB :: STRLECounterB s Int -> Int -> ST s ()
updateSTRLECounterB :: forall s. STRLECounterB s Int -> Int -> ST s ()
updateSTRLECounterB STRLECounterB s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STRLECounterB s Int
s Int
e
emptySTRLECounterB :: ST s (STRLECounterB s Int)
emptySTRLECounterB :: forall s. ST s (STRLECounterB s Int)
emptySTRLECounterB = forall a s. a -> ST s (STRef s a)
newSTRef (-Int
1)
vecToRLEB :: RLEVecB
-> ST s RLEVecB
vecToRLEB :: forall s.
Vector (Maybe ByteString) -> ST s (Vector (Maybe ByteString))
vecToRLEB (forall a. Vector a -> Maybe (a, Vector a)
DVB.uncons -> Maybe (Maybe ByteString, Vector (Maybe ByteString))
Nothing) = do
STRLEVecB s Any
brlevecstackempty <- forall s a. ST s (STRLEVecB s a)
emptySTRLEVecB
Vector (Maybe ByteString)
brlevecstackemptyr <- forall s a. STRef s a -> ST s a
readSTRef STRLEVecB s Any
brlevecstackempty
forall (m :: * -> *) a. Monad m => a -> m a
return Vector (Maybe ByteString)
brlevecstackemptyr
vecToRLEB (forall a. Vector a -> Maybe (a, Vector a)
DVB.uncons -> Just (Maybe ByteString
v,Vector (Maybe ByteString)
vs)) = do
STRLEVecB s Any
brlevecstack <- forall s a. ST s (STRLEVecB s a)
emptySTRLEVecB
STRLECounterB s Int
brlecounterstack <- forall s. ST s (STRLECounterB s Int)
emptySTRLECounterB
STRLETempB s Any
brletempstack <- forall s a. ST s (STRLETempB s a)
emptySTRLETempB
forall s. STRLECounterB s Int -> Int -> ST s ()
updateSTRLECounterB STRLECounterB s Int
brlecounterstack
Int
1
forall s.
STRLETempB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
updateSTRLETempB STRLETempB s Any
brletempstack
Maybe ByteString
v
forall {s}.
Vector (Maybe ByteString)
-> STRLEVecB s (Maybe ByteString)
-> STRef s Int
-> STRef s (Maybe ByteString)
-> ST s ()
iRLEB Vector (Maybe ByteString)
vs
STRLEVecB s Any
brlevecstack
STRLECounterB s Int
brlecounterstack
STRLETempB s Any
brletempstack
Vector (Maybe ByteString)
brlevecstackr <- forall s a. STRef s a -> ST s a
readSTRef STRLEVecB s Any
brlevecstack
forall (m :: * -> *) a. Monad m => a -> m a
return Vector (Maybe ByteString)
brlevecstackr
where
iRLEB :: Vector (Maybe ByteString)
-> STRLEVecB s (Maybe ByteString)
-> STRef s Int
-> STRef s (Maybe ByteString)
-> ST s ()
iRLEB (forall a. Vector a -> Maybe (a, Vector a)
DVB.uncons -> Maybe (Maybe ByteString, Vector (Maybe ByteString))
Nothing) STRLEVecB s (Maybe ByteString)
brless STRef s Int
brlecs STRef s (Maybe ByteString)
brlets = do
Int
cbrlecs <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
brlecs
Maybe ByteString
cbrlets <- forall s a. STRef s a -> ST s a
readSTRef STRef s (Maybe ByteString)
brlets
forall s.
STRLEVecB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
pushSTRLEVecB STRLEVecB s (Maybe ByteString)
brless
(forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
String -> ByteString
BSC8.pack forall a b. (a -> b) -> a -> b
$
forall a. Show a => a -> String
show Int
cbrlecs)
forall s.
STRLEVecB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
pushSTRLEVecB STRLEVecB s (Maybe ByteString)
brless
Maybe ByteString
cbrlets
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iRLEB (forall a. Vector a -> Maybe (a, Vector a)
DVB.uncons -> Just (Maybe ByteString
y,Vector (Maybe ByteString)
ys)) STRLEVecB s (Maybe ByteString)
brless STRef s Int
brlecs STRef s (Maybe ByteString)
brlets = do
Int
cbrlecs <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
brlecs
Maybe ByteString
cbrlets <- forall s a. STRef s a -> ST s a
readSTRef STRef s (Maybe ByteString)
brlets
if | forall a. Maybe a -> Bool
isNothing Maybe ByteString
y
-> do forall s.
STRLEVecB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
pushSTRLEVecB STRLEVecB s (Maybe ByteString)
brless
(forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
String -> ByteString
BSC8.pack forall a b. (a -> b) -> a -> b
$
forall a. Show a => a -> String
show Int
cbrlecs)
forall s.
STRLEVecB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
pushSTRLEVecB STRLEVecB s (Maybe ByteString)
brless
Maybe ByteString
cbrlets
forall s.
STRLEVecB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
pushSTRLEVecB STRLEVecB s (Maybe ByteString)
brless
(forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
String -> ByteString
BSC8.pack forall a b. (a -> b) -> a -> b
$
forall a. Show a => a -> String
show (Int
1 :: Int))
forall s.
STRLEVecB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
pushSTRLEVecB STRLEVecB s (Maybe ByteString)
brless
forall a. Maybe a
Nothing
forall s.
STRLETempB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
updateSTRLETempB STRef s (Maybe ByteString)
brlets
forall a. Maybe a
Nothing
Vector (Maybe ByteString)
-> STRLEVecB s (Maybe ByteString)
-> STRef s Int
-> STRef s (Maybe ByteString)
-> ST s ()
iRLEB Vector (Maybe ByteString)
ys
STRLEVecB s (Maybe ByteString)
brless
STRef s Int
brlecs
STRef s (Maybe ByteString)
brlets
| forall a. Maybe a -> Bool
isNothing Maybe ByteString
cbrlets
-> do forall s. STRLECounterB s Int -> Int -> ST s ()
updateSTRLECounterB STRef s Int
brlecs
Int
1
forall s.
STRLETempB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
updateSTRLETempB STRef s (Maybe ByteString)
brlets
Maybe ByteString
y
Vector (Maybe ByteString)
-> STRLEVecB s (Maybe ByteString)
-> STRef s Int
-> STRef s (Maybe ByteString)
-> ST s ()
iRLEB Vector (Maybe ByteString)
ys
STRLEVecB s (Maybe ByteString)
brless
STRef s Int
brlecs
STRef s (Maybe ByteString)
brlets
| forall a. HasCallStack => Maybe a -> a
fromJust Maybe ByteString
cbrlets forall a. Eq a => a -> a -> Bool
== forall a. HasCallStack => Maybe a -> a
fromJust Maybe ByteString
y
-> do forall s. STRLECounterB s Int -> Int -> ST s ()
updateSTRLECounterB STRef s Int
brlecs
(Int
cbrlecs forall a. Num a => a -> a -> a
+ Int
1)
Vector (Maybe ByteString)
-> STRLEVecB s (Maybe ByteString)
-> STRef s Int
-> STRef s (Maybe ByteString)
-> ST s ()
iRLEB Vector (Maybe ByteString)
ys
STRLEVecB s (Maybe ByteString)
brless
STRef s Int
brlecs
STRef s (Maybe ByteString)
brlets
| Bool
otherwise
-> do forall s.
STRLEVecB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
pushSTRLEVecB STRLEVecB s (Maybe ByteString)
brless
(forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
String -> ByteString
BSC8.pack forall a b. (a -> b) -> a -> b
$
forall a. Show a => a -> String
show Int
cbrlecs)
forall s.
STRLEVecB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
pushSTRLEVecB STRLEVecB s (Maybe ByteString)
brless
Maybe ByteString
cbrlets
forall s. STRLECounterB s Int -> Int -> ST s ()
updateSTRLECounterB STRef s Int
brlecs
Int
1
forall s.
STRLETempB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
updateSTRLETempB STRef s (Maybe ByteString)
brlets
Maybe ByteString
y
Vector (Maybe ByteString)
-> STRLEVecB s (Maybe ByteString)
-> STRef s Int
-> STRef s (Maybe ByteString)
-> ST s ()
iRLEB Vector (Maybe ByteString)
ys
STRLEVecB s (Maybe ByteString)
brless
STRef s Int
brlecs
STRef s (Maybe ByteString)
brlets
type RLEVecT = DVB.Vector (Maybe Text)
type STRLEVecT s a = STRef s RLEVecT
pushSTRLEVecT :: STRLEVecT s (Maybe Text) -> (Maybe Text) -> ST s ()
pushSTRLEVecT :: forall s. STRLEVecT s (Maybe Text) -> Maybe Text -> ST s ()
pushSTRLEVecT STRLEVecT s (Maybe Text)
s Maybe Text
Nothing = do
Vector (Maybe Text)
s2 <- forall s a. STRef s a -> ST s a
readSTRef STRLEVecT s (Maybe Text)
s
forall s a. STRef s a -> a -> ST s ()
writeSTRef STRLEVecT s (Maybe Text)
s (forall a. Vector a -> a -> Vector a
DVB.snoc Vector (Maybe Text)
s2 forall a. Maybe a
Nothing)
pushSTRLEVecT STRLEVecT s (Maybe Text)
s (Just Text
e) = do
Vector (Maybe Text)
s2 <- forall s a. STRef s a -> ST s a
readSTRef STRLEVecT s (Maybe Text)
s
forall s a. STRef s a -> a -> ST s ()
writeSTRef STRLEVecT s (Maybe Text)
s (forall a. Vector a -> a -> Vector a
DVB.snoc Vector (Maybe Text)
s2 (forall a. a -> Maybe a
Just Text
e))
emptySTRLEVecT :: ST s (STRLEVecT s a)
emptySTRLEVecT :: forall s a. ST s (STRLEVecT s a)
emptySTRLEVecT = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Vector a
DVB.empty
type STRLETempT s a = STRef s (Maybe Text)
updateSTRLETempT :: STRLETempT s (Maybe Text) -> (Maybe Text) -> ST s ()
updateSTRLETempT :: forall s. STRLETempT s (Maybe Text) -> Maybe Text -> ST s ()
updateSTRLETempT STRLETempT s (Maybe Text)
s Maybe Text
Nothing = forall s a. STRef s a -> a -> ST s ()
writeSTRef STRLETempT s (Maybe Text)
s forall a. Maybe a
Nothing
updateSTRLETempT STRLETempT s (Maybe Text)
s (Just Text
e) = forall s a. STRef s a -> a -> ST s ()
writeSTRef STRLETempT s (Maybe Text)
s (forall a. a -> Maybe a
Just Text
e)
emptySTRLETempT :: ST s (STRLETempT s a)
emptySTRLETempT :: forall s a. ST s (STRLETempT s a)
emptySTRLETempT = forall a s. a -> ST s (STRef s a)
newSTRef (forall a. a -> Maybe a
Just Text
DText.empty)
type STRLECounterT s a = STRef s Int
updateSTRLECounterT :: STRLECounterT s Int -> Int -> ST s ()
updateSTRLECounterT :: forall s. STRLECounterB s Int -> Int -> ST s ()
updateSTRLECounterT STRLECounterT s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STRLECounterT s Int
s Int
e
emptySTRLECounterT :: ST s (STRLECounterT s Int)
emptySTRLECounterT :: forall s. ST s (STRLECounterB s Int)
emptySTRLECounterT = forall a s. a -> ST s (STRef s a)
newSTRef (-Int
1)
vecToRLET :: RLEVecT ->
ST s RLEVecT
vecToRLET :: forall s. Vector (Maybe Text) -> ST s (Vector (Maybe Text))
vecToRLET (forall a. Vector a -> Maybe (a, Vector a)
DVB.uncons -> Maybe (Maybe Text, Vector (Maybe Text))
Nothing) = do
STRLEVecT s Any
trlevecstackempty <- forall s a. ST s (STRLEVecT s a)
emptySTRLEVecT
Vector (Maybe Text)
trlevecstackemptyr <- forall s a. STRef s a -> ST s a
readSTRef STRLEVecT s Any
trlevecstackempty
forall (m :: * -> *) a. Monad m => a -> m a
return Vector (Maybe Text)
trlevecstackemptyr
vecToRLET (forall a. Vector a -> Maybe (a, Vector a)
DVB.uncons -> Just (Maybe Text
v,Vector (Maybe Text)
vs)) = do
STRLEVecT s Any
trlevecstack <- forall s a. ST s (STRLEVecT s a)
emptySTRLEVecT
STRLECounterT s Int
trlecounterstack <- forall s. ST s (STRLECounterB s Int)
emptySTRLECounterT
STRLETempT s Any
trletempstack <- forall s a. ST s (STRLETempT s a)
emptySTRLETempT
forall s. STRLECounterB s Int -> Int -> ST s ()
updateSTRLECounterT STRLECounterT s Int
trlecounterstack
Int
1
forall s. STRLETempT s (Maybe Text) -> Maybe Text -> ST s ()
updateSTRLETempT STRLETempT s Any
trletempstack
Maybe Text
v
forall {s}.
Vector (Maybe Text)
-> STRLEVecT s (Maybe Text)
-> STRef s Int
-> STRef s (Maybe Text)
-> ST s ()
iRLET Vector (Maybe Text)
vs
STRLEVecT s Any
trlevecstack
STRLECounterT s Int
trlecounterstack
STRLETempT s Any
trletempstack
Vector (Maybe Text)
trlevecstackr <- forall s a. STRef s a -> ST s a
readSTRef STRLEVecT s Any
trlevecstack
forall (m :: * -> *) a. Monad m => a -> m a
return Vector (Maybe Text)
trlevecstackr
where
iRLET :: Vector (Maybe Text)
-> STRLEVecT s (Maybe Text)
-> STRef s Int
-> STRef s (Maybe Text)
-> ST s ()
iRLET (forall a. Vector a -> Maybe (a, Vector a)
DVB.uncons -> Maybe (Maybe Text, Vector (Maybe Text))
Nothing) STRLEVecT s (Maybe Text)
trless STRef s Int
trlecs STRef s (Maybe Text)
trlets = do
Int
ctrlecs <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
trlecs
Maybe Text
ctrlets <- forall s a. STRef s a -> ST s a
readSTRef STRef s (Maybe Text)
trlets
forall s. STRLEVecT s (Maybe Text) -> Maybe Text -> ST s ()
pushSTRLEVecT STRLEVecT s (Maybe Text)
trless
(forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
String -> Text
DText.pack forall a b. (a -> b) -> a -> b
$
forall a. Show a => a -> String
show Int
ctrlecs)
forall s. STRLEVecT s (Maybe Text) -> Maybe Text -> ST s ()
pushSTRLEVecT STRLEVecT s (Maybe Text)
trless
Maybe Text
ctrlets
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iRLET (forall a. Vector a -> Maybe (a, Vector a)
DVB.uncons -> Just (Maybe Text
y,Vector (Maybe Text)
ys)) STRLEVecT s (Maybe Text)
trless STRef s Int
trlecs STRef s (Maybe Text)
trlets = do
Int
ctrlecs <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
trlecs
Maybe Text
ctrlets <- forall s a. STRef s a -> ST s a
readSTRef STRef s (Maybe Text)
trlets
if | forall a. Maybe a -> Bool
isNothing Maybe Text
y
-> do forall s. STRLEVecT s (Maybe Text) -> Maybe Text -> ST s ()
pushSTRLEVecT STRLEVecT s (Maybe Text)
trless
(forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
String -> Text
DText.pack forall a b. (a -> b) -> a -> b
$
forall a. Show a => a -> String
show Int
ctrlecs)
forall s. STRLEVecT s (Maybe Text) -> Maybe Text -> ST s ()
pushSTRLEVecT STRLEVecT s (Maybe Text)
trless
Maybe Text
ctrlets
forall s. STRLEVecT s (Maybe Text) -> Maybe Text -> ST s ()
pushSTRLEVecT STRLEVecT s (Maybe Text)
trless
(forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
String -> Text
DText.pack forall a b. (a -> b) -> a -> b
$
forall a. Show a => a -> String
show (Int
1 :: Int))
forall s. STRLEVecT s (Maybe Text) -> Maybe Text -> ST s ()
pushSTRLEVecT STRLEVecT s (Maybe Text)
trless
forall a. Maybe a
Nothing
forall s. STRLETempT s (Maybe Text) -> Maybe Text -> ST s ()
updateSTRLETempT STRef s (Maybe Text)
trlets
forall a. Maybe a
Nothing
Vector (Maybe Text)
-> STRLEVecT s (Maybe Text)
-> STRef s Int
-> STRef s (Maybe Text)
-> ST s ()
iRLET Vector (Maybe Text)
ys
STRLEVecT s (Maybe Text)
trless
STRef s Int
trlecs
STRef s (Maybe Text)
trlets
| forall a. Maybe a -> Bool
isNothing Maybe Text
ctrlets
-> do forall s. STRLECounterB s Int -> Int -> ST s ()
updateSTRLECounterT STRef s Int
trlecs
Int
1
forall s. STRLETempT s (Maybe Text) -> Maybe Text -> ST s ()
updateSTRLETempT STRef s (Maybe Text)
trlets
Maybe Text
y
Vector (Maybe Text)
-> STRLEVecT s (Maybe Text)
-> STRef s Int
-> STRef s (Maybe Text)
-> ST s ()
iRLET Vector (Maybe Text)
ys
STRLEVecT s (Maybe Text)
trless
STRef s Int
trlecs
STRef s (Maybe Text)
trlets
| forall a. HasCallStack => Maybe a -> a
fromJust Maybe Text
ctrlets forall a. Eq a => a -> a -> Bool
== forall a. HasCallStack => Maybe a -> a
fromJust Maybe Text
y
-> do forall s. STRLECounterB s Int -> Int -> ST s ()
updateSTRLECounterT STRef s Int
trlecs
(Int
ctrlecs forall a. Num a => a -> a -> a
+ Int
1)
Vector (Maybe Text)
-> STRLEVecT s (Maybe Text)
-> STRef s Int
-> STRef s (Maybe Text)
-> ST s ()
iRLET Vector (Maybe Text)
ys
STRLEVecT s (Maybe Text)
trless
STRef s Int
trlecs
STRef s (Maybe Text)
trlets
| Bool
otherwise
-> do forall s. STRLEVecT s (Maybe Text) -> Maybe Text -> ST s ()
pushSTRLEVecT STRLEVecT s (Maybe Text)
trless
(forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
String -> Text
DText.pack forall a b. (a -> b) -> a -> b
$
forall a. Show a => a -> String
show Int
ctrlecs)
forall s. STRLEVecT s (Maybe Text) -> Maybe Text -> ST s ()
pushSTRLEVecT STRLEVecT s (Maybe Text)
trless
Maybe Text
ctrlets
forall s. STRLECounterB s Int -> Int -> ST s ()
updateSTRLECounterT STRef s Int
trlecs
Int
1
forall s. STRLETempT s (Maybe Text) -> Maybe Text -> ST s ()
updateSTRLETempT STRef s (Maybe Text)
trlets
Maybe Text
y
Vector (Maybe Text)
-> STRLEVecT s (Maybe Text)
-> STRef s Int
-> STRef s (Maybe Text)
-> ST s ()
iRLET Vector (Maybe Text)
ys
STRLEVecT s (Maybe Text)
trless
STRef s Int
trlecs
STRef s (Maybe Text)
trlets
unconsb2 :: DVB.Vector a -> Maybe (a,DVB.Vector a,Maybe (DVB.Vector a))
unconsb2 :: forall a. Vector a -> Maybe (a, Vector a, Maybe (Vector a))
unconsb2 Vector a
v = if | forall a. Vector a -> Int
DVB.length Vector a
v forall a. Ord a => a -> a -> Bool
< Int
3
-> forall a. a -> Maybe a
Just (forall a. Vector a -> a
DVB.unsafeHead Vector a
v,forall a. Int -> Vector a -> Vector a
DVB.drop Int
1 Vector a
v,forall a. Maybe a
Nothing)
| Bool
otherwise
-> forall a. a -> Maybe a
Just (forall a. Vector a -> a
DVB.unsafeHead Vector a
v,forall a. Int -> Vector a -> Vector a
DVB.drop Int
1 Vector a
v,forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Int -> Vector a -> Vector a
DVB.drop Int
2 Vector a
v)
type FRLEVecB = DVB.Vector (Maybe ByteString)
type FSTRLEVecB s a = STRef s FRLEVecB
pushFSTRLEVecB :: FSTRLEVecB s (Maybe ByteString) -> (Maybe ByteString) -> ST s ()
pushFSTRLEVecB :: forall s.
STRLEVecB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
pushFSTRLEVecB FSTRLEVecB s (Maybe ByteString)
s Maybe ByteString
Nothing = do
Vector (Maybe ByteString)
s2 <- forall s a. STRef s a -> ST s a
readSTRef FSTRLEVecB s (Maybe ByteString)
s
forall s a. STRef s a -> a -> ST s ()
writeSTRef FSTRLEVecB s (Maybe ByteString)
s (forall a. Vector a -> a -> Vector a
DVB.snoc Vector (Maybe ByteString)
s2 forall a. Maybe a
Nothing)
pushFSTRLEVecB FSTRLEVecB s (Maybe ByteString)
s (Just ByteString
e) = do
Vector (Maybe ByteString)
s2 <- forall s a. STRef s a -> ST s a
readSTRef FSTRLEVecB s (Maybe ByteString)
s
forall s a. STRef s a -> a -> ST s ()
writeSTRef FSTRLEVecB s (Maybe ByteString)
s (forall a. Vector a -> a -> Vector a
DVB.snoc Vector (Maybe ByteString)
s2 (forall a. a -> Maybe a
Just ByteString
e))
emptyFSTRLEVecB :: ST s (FSTRLEVecB s a)
emptyFSTRLEVecB :: forall s a. ST s (STRLEVecB s a)
emptyFSTRLEVecB = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Vector a
DVB.empty
vecFromRLEB :: RLEB
-> ST s FRLEVecB
vecFromRLEB :: forall s. RLEB -> ST s (Vector (Maybe ByteString))
vecFromRLEB (RLEB (forall a. Vector a -> Maybe (a, Vector a)
DVB.uncons -> Maybe (Maybe ByteString, Vector (Maybe ByteString))
Nothing)) = do
FSTRLEVecB s Any
fbrlevecstackempty <- forall s a. ST s (STRLEVecB s a)
emptyFSTRLEVecB
Vector (Maybe ByteString)
fbrlevecstackemptyr <- forall s a. STRef s a -> ST s a
readSTRef FSTRLEVecB s Any
fbrlevecstackempty
forall (m :: * -> *) a. Monad m => a -> m a
return Vector (Maybe ByteString)
fbrlevecstackemptyr
vecFromRLEB RLEB
vs = do
FSTRLEVecB s Any
fbrlevecstack <- forall s a. ST s (STRLEVecB s a)
emptySTRLEVecB
let rlebvec :: Vector (Maybe ByteString)
rlebvec = (\(RLEB Vector (Maybe ByteString)
b) -> Vector (Maybe ByteString)
b) RLEB
vs
forall {s}.
Vector (Maybe ByteString)
-> FSTRLEVecB s (Maybe ByteString) -> ST s ()
iFRLEB Vector (Maybe ByteString)
rlebvec
FSTRLEVecB s Any
fbrlevecstack
Vector (Maybe ByteString)
fbrlevecstackr <- forall s a. STRef s a -> ST s a
readSTRef FSTRLEVecB s Any
fbrlevecstack
forall (m :: * -> *) a. Monad m => a -> m a
return Vector (Maybe ByteString)
fbrlevecstackr
where
iFRLEB :: Vector (Maybe ByteString)
-> FSTRLEVecB s (Maybe ByteString) -> ST s ()
iFRLEB (forall a. Vector a -> Maybe (a, Vector a, Maybe (Vector a))
unconsb2 -> Just (Maybe ByteString
y1,Vector (Maybe ByteString)
y2,Maybe (Vector (Maybe ByteString))
Nothing)) FSTRLEVecB s (Maybe ByteString)
fbrless =
if | forall a. Maybe a -> Bool
isJust Maybe ByteString
y1 Bool -> Bool -> Bool
&&
forall a. Maybe a -> Bool
isNothing (forall a. Vector a -> a
DVB.head Vector (Maybe ByteString)
y2)
-> do forall s.
STRLEVecB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
pushFSTRLEVecB FSTRLEVecB s (Maybe ByteString)
fbrless
forall a. Maybe a
Nothing
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
| Bool
otherwise
-> do let y1' :: Int
y1' = forall a. Read a => String -> a
read forall a b. (a -> b) -> a -> b
$
ByteString -> String
BSC8.unpack forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe ByteString
y1 :: Int
let y2' :: ByteString
y2' = forall a. HasCallStack => Maybe a -> a
fromJust forall a b. (a -> b) -> a -> b
$
forall a. Vector a -> a
DVB.head Vector (Maybe ByteString)
y2
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
CM.replicateM_ Int
y1'
(forall s.
STRLEVecB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
pushFSTRLEVecB FSTRLEVecB s (Maybe ByteString)
fbrless
(forall a. a -> Maybe a
Just ByteString
y2'))
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iFRLEB (forall a. Vector a -> Maybe (a, Vector a, Maybe (Vector a))
unconsb2 -> Just (Maybe ByteString
y1,Vector (Maybe ByteString)
y2,Just Vector (Maybe ByteString)
ys)) FSTRLEVecB s (Maybe ByteString)
fbrless =
if | forall a. Maybe a -> Bool
isJust Maybe ByteString
y1 Bool -> Bool -> Bool
&&
forall a. Maybe a -> Bool
isNothing (forall a. Vector a -> a
DVB.head Vector (Maybe ByteString)
y2)
-> do forall s.
STRLEVecB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
pushFSTRLEVecB FSTRLEVecB s (Maybe ByteString)
fbrless
forall a. Maybe a
Nothing
Vector (Maybe ByteString)
-> FSTRLEVecB s (Maybe ByteString) -> ST s ()
iFRLEB Vector (Maybe ByteString)
ys
FSTRLEVecB s (Maybe ByteString)
fbrless
| Bool
otherwise
-> do let y1' :: Int
y1' = forall a. Read a => String -> a
read forall a b. (a -> b) -> a -> b
$
ByteString -> String
BSC8.unpack forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe ByteString
y1 :: Int
let y2' :: ByteString
y2' = forall a. HasCallStack => Maybe a -> a
fromJust forall a b. (a -> b) -> a -> b
$
forall a. Vector a -> a
DVB.head Vector (Maybe ByteString)
y2
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
CM.replicateM_ Int
y1'
(forall s.
STRLEVecB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
pushFSTRLEVecB FSTRLEVecB s (Maybe ByteString)
fbrless
(forall a. a -> Maybe a
Just ByteString
y2'))
Vector (Maybe ByteString)
-> FSTRLEVecB s (Maybe ByteString) -> ST s ()
iFRLEB Vector (Maybe ByteString)
ys
FSTRLEVecB s (Maybe ByteString)
fbrless
unconst2 :: DVB.Vector a -> Maybe (a,DVB.Vector a, Maybe (DVB.Vector a))
unconst2 :: forall a. Vector a -> Maybe (a, Vector a, Maybe (Vector a))
unconst2 Vector a
v = if | forall a. Vector a -> Int
DVB.length Vector a
v forall a. Ord a => a -> a -> Bool
< Int
3
-> forall a. a -> Maybe a
Just (forall a. Vector a -> a
DVB.unsafeHead Vector a
v,forall a. Int -> Vector a -> Vector a
DVB.drop Int
1 Vector a
v,forall a. Maybe a
Nothing)
| Bool
otherwise
-> forall a. a -> Maybe a
Just (forall a. Vector a -> a
DVB.unsafeHead Vector a
v, forall a. Int -> Vector a -> Vector a
DVB.drop Int
1 Vector a
v,forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Int -> Vector a -> Vector a
DVB.drop Int
2 Vector a
v)
type FRLEVecT = DVB.Vector (Maybe Text)
type FSTRLEVecT s a = STRef s FRLEVecT
pushFSTRLEVecT :: FSTRLEVecT s (Maybe Text) -> (Maybe Text) -> ST s ()
pushFSTRLEVecT :: forall s. STRLEVecT s (Maybe Text) -> Maybe Text -> ST s ()
pushFSTRLEVecT FSTRLEVecT s (Maybe Text)
s Maybe Text
Nothing = do
Vector (Maybe Text)
s2 <- forall s a. STRef s a -> ST s a
readSTRef FSTRLEVecT s (Maybe Text)
s
forall s a. STRef s a -> a -> ST s ()
writeSTRef FSTRLEVecT s (Maybe Text)
s (forall a. Vector a -> a -> Vector a
DVB.snoc Vector (Maybe Text)
s2 forall a. Maybe a
Nothing)
pushFSTRLEVecT FSTRLEVecT s (Maybe Text)
s (Just Text
e) = do
Vector (Maybe Text)
s2 <- forall s a. STRef s a -> ST s a
readSTRef FSTRLEVecT s (Maybe Text)
s
forall s a. STRef s a -> a -> ST s ()
writeSTRef FSTRLEVecT s (Maybe Text)
s (forall a. Vector a -> a -> Vector a
DVB.snoc Vector (Maybe Text)
s2 (forall a. a -> Maybe a
Just Text
e))
emptyFSTRLEVecT :: ST s (FSTRLEVecT s a)
emptyFSTRLEVecT :: forall s a. ST s (STRLEVecT s a)
emptyFSTRLEVecT = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Vector a
DVB.empty
vecFromRLET :: RLET ->
ST s FRLEVecT
vecFromRLET :: forall s. RLET -> ST s (Vector (Maybe Text))
vecFromRLET (RLET (forall a. Vector a -> Maybe (a, Vector a)
DVB.uncons -> Maybe (Maybe Text, Vector (Maybe Text))
Nothing)) = do
FSTRLEVecT s Any
ftrlevecstackempty <- forall s a. ST s (STRLEVecT s a)
emptyFSTRLEVecT
Vector (Maybe Text)
ftrlevecstackemptyr <- forall s a. STRef s a -> ST s a
readSTRef FSTRLEVecT s Any
ftrlevecstackempty
forall (m :: * -> *) a. Monad m => a -> m a
return Vector (Maybe Text)
ftrlevecstackemptyr
vecFromRLET RLET
vs = do
FSTRLEVecT s Any
ftrlevecstack <- forall s a. ST s (STRLEVecT s a)
emptySTRLEVecT
let rletvec :: Vector (Maybe Text)
rletvec = (\(RLET Vector (Maybe Text)
t) -> Vector (Maybe Text)
t) RLET
vs
forall {s}.
Vector (Maybe Text) -> FSTRLEVecT s (Maybe Text) -> ST s ()
iFRLET Vector (Maybe Text)
rletvec
FSTRLEVecT s Any
ftrlevecstack
Vector (Maybe Text)
ftrlevecstackr <- forall s a. STRef s a -> ST s a
readSTRef FSTRLEVecT s Any
ftrlevecstack
forall (m :: * -> *) a. Monad m => a -> m a
return Vector (Maybe Text)
ftrlevecstackr
where
iFRLET :: Vector (Maybe Text) -> FSTRLEVecT s (Maybe Text) -> ST s ()
iFRLET (forall a. Vector a -> Maybe (a, Vector a, Maybe (Vector a))
unconst2 -> Just (Maybe Text
y1,Vector (Maybe Text)
y2,Maybe (Vector (Maybe Text))
Nothing)) FSTRLEVecT s (Maybe Text)
ftrless =
if | forall a. Maybe a -> Bool
isJust Maybe Text
y1 Bool -> Bool -> Bool
&&
forall a. Maybe a -> Bool
isNothing (forall a. Vector a -> a
DVB.head Vector (Maybe Text)
y2)
-> do forall s. STRLEVecT s (Maybe Text) -> Maybe Text -> ST s ()
pushFSTRLEVecT FSTRLEVecT s (Maybe Text)
ftrless
forall a. Maybe a
Nothing
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
| Bool
otherwise
-> do let y1' :: Int
y1' = forall a. Read a => String -> a
read forall a b. (a -> b) -> a -> b
$
Text -> String
DText.unpack forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Text
y1 :: Int
let y2' :: Text
y2' = forall a. HasCallStack => Maybe a -> a
fromJust forall a b. (a -> b) -> a -> b
$
forall a. Vector a -> a
DVB.head Vector (Maybe Text)
y2
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
CM.replicateM_ Int
y1'
(forall s. STRLEVecT s (Maybe Text) -> Maybe Text -> ST s ()
pushFSTRLEVecT FSTRLEVecT s (Maybe Text)
ftrless
(forall a. a -> Maybe a
Just Text
y2'))
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iFRLET (forall a. Vector a -> Maybe (a, Vector a, Maybe (Vector a))
unconst2 -> Just (Maybe Text
y1,Vector (Maybe Text)
y2,Just Vector (Maybe Text)
ys)) FSTRLEVecT s (Maybe Text)
ftrless =
if | forall a. Maybe a -> Bool
isJust Maybe Text
y1 Bool -> Bool -> Bool
&&
forall a. Maybe a -> Bool
isNothing (forall a. Vector a -> a
DVB.head Vector (Maybe Text)
y2)
-> do forall s. STRLEVecT s (Maybe Text) -> Maybe Text -> ST s ()
pushFSTRLEVecT FSTRLEVecT s (Maybe Text)
ftrless
forall a. Maybe a
Nothing
Vector (Maybe Text) -> FSTRLEVecT s (Maybe Text) -> ST s ()
iFRLET Vector (Maybe Text)
ys
FSTRLEVecT s (Maybe Text)
ftrless
| Bool
otherwise
-> do let y1' :: Int
y1' = forall a. Read a => String -> a
read forall a b. (a -> b) -> a -> b
$
Text -> String
DText.unpack forall a b. (a -> b) -> a -> b
$
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Text
y1 :: Int
let y2' :: Text
y2' = forall a. HasCallStack => Maybe a -> a
fromJust forall a b. (a -> b) -> a -> b
$
forall a. Vector a -> a
DVB.head Vector (Maybe Text)
y2
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
CM.replicateM_ Int
y1'
(forall s. STRLEVecT s (Maybe Text) -> Maybe Text -> ST s ()
pushFSTRLEVecT FSTRLEVecT s (Maybe Text)
ftrless
(forall a. a -> Maybe a
Just Text
y2'))
Vector (Maybe Text) -> FSTRLEVecT s (Maybe Text) -> ST s ()
iFRLET Vector (Maybe Text)
ys
FSTRLEVecT s (Maybe Text)
ftrless