{-# LANGUAGE MultiWayIf       #-}
{-# LANGUAGE ViewPatterns     #-}
{-# LANGUAGE Strict           #-}
{-# LANGUAGE DeriveGeneric    #-}
{-# LANGUAGE TypeApplications #-}


-- |
-- Module      :  Data.RLE.Internal
-- Copyright   :  (c) Matthew Mosior 2022
-- License     :  BSD-style
-- Maintainer  :  mattm.github@gmail.com
-- Portability :  portable
--
-- = WARNING
--
-- This module is considered __internal__.
--
-- The Package Versioning Policy __does not apply__.
--
-- The contents of this module may change __in any way whatsoever__
-- and __without any warning__ between minor versions of this package.
--
-- Authors importing this library are expected to track development
-- closely.
--
-- All credit goes to the author(s)/maintainer(s) of the
-- [containers](https://hackage.haskell.org/package/containers) library
-- for the above warning text.
--
-- = Description
--
-- Various data structures and custom data types to describe the Run-length encoding (RLE)
-- and the Inverse RLE implementations, namely 'vecToRLEB', 'vecToRLET', 'vecFromRLEB', and 'vecFromRLET'.
--
-- The RLE implementations rely heavily upon 'DVB.Vector' provided by the [vector](https://hackage.haskell.org/package/vector) library,
-- 'STRef' and associated functions in the [stref](https://hackage.haskell.org/package/base-4.17.0.0/docs/Data-STRef.html) library,
-- and 'runST' in the [Control.Monad.ST](https://hackage.haskell.org/package/base-4.17.0.0/docs/Control-Monad-ST.html) library.


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


{-Base level types.-}

-- | Basic RLE ('ByteString') data type.
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)

-- | Basic RLE ('Text') data type.
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)

{-------------------}


{-toRLE (ByteString) functions.-}

-- | Abstract 'RLEVecB' type utilizing a sequence.
type RLEVecB = DVB.Vector (Maybe ByteString)

-- | Abstract data type representing a 'RLEVecB' in the (strict) ST monad.
type STRLEVecB s a = STRef s RLEVecB

-- | State function to push 'RLEVecB' data into stack.
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))

-- | State function to create empty 'STRLEVecB' type.
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

-- | Abstract 'STRLETempB' and associated state type.
type STRLETempB s a = STRef s (Maybe ByteString)

-- | State function to update 'STRLETempB'.
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)

-- | State function to create empty 'STRLETempB' type.
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)

-- | Abstract 'STRLECounterB' state type.
type STRLECounterB s a = STRef s Int

-- | State function to update 'STRLECounterB'.
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

-- | State function to create empty 'STRLECounterB' type.
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)

-- | Strict state monad function.
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

{-------------------------------}


{-toRLE (Text) functions.-}

-- | Abstract 'RLEVecT' type utilizing a sequence.
type RLEVecT = DVB.Vector (Maybe Text)

-- | Abstract data type representing a 'RLEVecT' in the (strict) ST monad.
type STRLEVecT s a = STRef s RLEVecT

-- | State function to push 'RLEVecT' data into stack.
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))

-- | State function to create empty 'STRLEVecT' type.
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

-- | Abstract 'STRLETempT' state type.
type STRLETempT s a = STRef s (Maybe Text)

-- | State function to update 'STRLETempT'.
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)

-- | State function to create empty 'STRLETempT' type.
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)

-- | Abstract 'STRLECounterT' and associated state type.
type STRLECounterT s a = STRef s Int

-- | State function to update 'STRLECounterT'.
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

-- | State function to create empty 'STRLECounterT' type.
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)

-- | Strict state monad function.
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

{-------------------------}


{-fromRLE (ByteString) functions.-}

-- | 'DVB.Vector' auxilary function
-- to pattern match on first two elements
-- of a vector.
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)

-- | Abstract 'FRLEVecB' type utilizing a sequence.
type FRLEVecB = DVB.Vector (Maybe ByteString)

-- | Abstract data type representing a 'FRLEVecB' in the (strict) ST monad.
type FSTRLEVecB s a = STRef s FRLEVecB

-- | State function to push 'FRLEVecB' data into stack.
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))

-- | State function to create empty 'FSTRLEVecB' type.
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

-- | Strict state monad function.
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

{---------------------------------}


{-fromRLE (Text) functions.-}

-- | 'DVB.Vector' auxilary function
-- to pattern match on first two elements
-- of a vector.
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)

-- | Abstract 'FRLEVecT' type utilizing a sequence.
type FRLEVecT = DVB.Vector (Maybe Text)

-- | Abstract data type representing a 'FRLEVecT' in the (strict) ST monad.
type FSTRLEVecT s a = STRef s FRLEVecT

-- | State function to push 'FSTRLEVecT' data into stack.
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))

-- | State function to create empty 'FSTRLEVecT' type.
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

-- | Strict state monad function.
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

{---------------------------}