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


-- |
-- Module      :  Data.FMIndex.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
-- [Full-text Minute-space index (FM-index)](https://en.wikipedia.org/wiki/FM-index)
-- and the Inverse FM-index implementations, namely 'seqToOccCKB', 'seqToOccCKT', 'seqToCcB', 'seqToCcT', 'seqFromFMIndexB', and 'seqFromFMIndexT'.
--
-- The FM-index implementations rely heavily upon 'Seq' provided by the [containers](https://hackage.haskell.org/package/containers),
-- '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.
--
-- = Example FM-index Output
--
-- The below example is taken from [this](https://en.wikipedia.org/wiki/FM-index) wikipedia page.
--
-- Given the following input, "abracadabra":
--
-- and
--
-- Given the following Burrows-Wheeler matrix (BWM) of the input "abracadabra":
--
-- +----+---+---------------------------------------+---+
-- | I  | F |                                       | L |
-- +====+===+===+===+===+===+===+===+===+===+===+===+===+
-- | 1  | $ | a | b | r | a | c | a | d | a | b | r | a |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 2  | a | $ | a | b | r | a | c | a | d | a | b | r |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 3  | a | b | r | a | $ | a | b | r | a | c | a | d |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 4  | a | b | r | a | c | a | d | a | b | r | a | $ |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 5  | a | c | a | d | a | b | r | a | $ | a | b | r |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 6  | a | d | a | b | r | a | $ | a | b | r | a | c |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 7  | b | r | a | $ | a | b | r | a | c | a | d | a |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 8  | b | r | a | c | a | d | a | b | r | a | $ | a |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 9  | c | a | d | a | b | r | a | $ | a | b | r | a |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 10 | d | a | b | r | a | $ | a | b | r | a | c | a |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 11 | r | a | $ | a | b | r | a | c | a | d | a | b |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 12 | r | a | c | a | d | a | b | r | a | $ | a | b |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
--
-- The FM-index output of the Burrows-Wheeler transform of the input is:
--
-- C[c] of "ard$rcaaaabb"
--
-- +------+---+---+---+---+---+----+
-- | c    | $ | a | b | c | d | r  |
-- +------+---+---+---+---+---+----+
-- | C[c] | 0 | 1 | 6 | 8 | 9 | 10 |
-- +------+---+---+---+---+---+----+
--
-- and
--
-- Occ(c,k) of "ard$rcaaaabb"
--
-- +---+---+---+---+---+---+---+---+---+---+----+----+----+
-- |   | a | r | d | $ | r | c | a | a | a | a  | b  | b  |
-- +---+---+---+---+---+---+---+---+---+---+----+----+----+
-- |   | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
-- +===+===+===+===+===+===+===+===+===+===+====+====+====+
-- | $ | 0 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1  | 1  | 1  |
-- +---+---+---+---+---+---+---+---+---+---+----+----+----+
-- | a | 1 | 1 | 1 | 1 | 1 | 1 | 2 | 3 | 4 | 5  | 5  | 5  |
-- +---+---+---+---+---+---+---+---+---+---+----+----+----+
-- | b | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0  | 1  | 2  |
-- +---+---+---+---+---+---+---+---+---+---+----+----+----+
-- | c | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | 1  | 1  | 1  |
-- +---+---+---+---+---+---+---+---+---+---+----+----+----+
-- | d | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1  | 1  | 1  |
-- +---+---+---+---+---+---+---+---+---+---+----+----+----+
-- | r | 0 | 1 | 1 | 1 | 2 | 2 | 2 | 2 | 2 | 2  | 2  | 2  |
-- +---+---+---+---+---+---+---+---+---+---+----+----+----+


module Data.FMIndex.Internal where

import Data.BWT.Internal()
import Data.MTF.Internal

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()
import Data.ByteString.Internal()
import Data.Foldable()
import Data.List()
import Data.Maybe()
import Data.Sequence as DS (Seq(..),ViewR(..),empty,(|>))
import Data.Sequence.Internal as DSI
import Data.STRef as DSTR
import Data.Text as DText
import GHC.Generics (Generic)
import Prelude as P


{-Base level types.-}

-- | Basic FMIndex ('ByteString') data type.
newtype FMIndexB = FMIndexB (CcB,OccCKB)
  deriving (FMIndexB -> FMIndexB -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FMIndexB -> FMIndexB -> Bool
$c/= :: FMIndexB -> FMIndexB -> Bool
== :: FMIndexB -> FMIndexB -> Bool
$c== :: FMIndexB -> FMIndexB -> Bool
Eq,Eq FMIndexB
FMIndexB -> FMIndexB -> Bool
FMIndexB -> FMIndexB -> Ordering
FMIndexB -> FMIndexB -> FMIndexB
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 :: FMIndexB -> FMIndexB -> FMIndexB
$cmin :: FMIndexB -> FMIndexB -> FMIndexB
max :: FMIndexB -> FMIndexB -> FMIndexB
$cmax :: FMIndexB -> FMIndexB -> FMIndexB
>= :: FMIndexB -> FMIndexB -> Bool
$c>= :: FMIndexB -> FMIndexB -> Bool
> :: FMIndexB -> FMIndexB -> Bool
$c> :: FMIndexB -> FMIndexB -> Bool
<= :: FMIndexB -> FMIndexB -> Bool
$c<= :: FMIndexB -> FMIndexB -> Bool
< :: FMIndexB -> FMIndexB -> Bool
$c< :: FMIndexB -> FMIndexB -> Bool
compare :: FMIndexB -> FMIndexB -> Ordering
$ccompare :: FMIndexB -> FMIndexB -> Ordering
Ord,Int -> FMIndexB -> ShowS
[FMIndexB] -> ShowS
FMIndexB -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FMIndexB] -> ShowS
$cshowList :: [FMIndexB] -> ShowS
show :: FMIndexB -> String
$cshow :: FMIndexB -> String
showsPrec :: Int -> FMIndexB -> ShowS
$cshowsPrec :: Int -> FMIndexB -> ShowS
Show,ReadPrec [FMIndexB]
ReadPrec FMIndexB
Int -> ReadS FMIndexB
ReadS [FMIndexB]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FMIndexB]
$creadListPrec :: ReadPrec [FMIndexB]
readPrec :: ReadPrec FMIndexB
$creadPrec :: ReadPrec FMIndexB
readList :: ReadS [FMIndexB]
$creadList :: ReadS [FMIndexB]
readsPrec :: Int -> ReadS FMIndexB
$creadsPrec :: Int -> ReadS FMIndexB
Read,forall x. Rep FMIndexB x -> FMIndexB
forall x. FMIndexB -> Rep FMIndexB x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FMIndexB x -> FMIndexB
$cfrom :: forall x. FMIndexB -> Rep FMIndexB x
Generic)

-- | Basic FMIndex ('Text') data type.
newtype FMIndexT = FMIndexT (CcT,OccCKT)
  deriving (FMIndexT -> FMIndexT -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FMIndexT -> FMIndexT -> Bool
$c/= :: FMIndexT -> FMIndexT -> Bool
== :: FMIndexT -> FMIndexT -> Bool
$c== :: FMIndexT -> FMIndexT -> Bool
Eq,Eq FMIndexT
FMIndexT -> FMIndexT -> Bool
FMIndexT -> FMIndexT -> Ordering
FMIndexT -> FMIndexT -> FMIndexT
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 :: FMIndexT -> FMIndexT -> FMIndexT
$cmin :: FMIndexT -> FMIndexT -> FMIndexT
max :: FMIndexT -> FMIndexT -> FMIndexT
$cmax :: FMIndexT -> FMIndexT -> FMIndexT
>= :: FMIndexT -> FMIndexT -> Bool
$c>= :: FMIndexT -> FMIndexT -> Bool
> :: FMIndexT -> FMIndexT -> Bool
$c> :: FMIndexT -> FMIndexT -> Bool
<= :: FMIndexT -> FMIndexT -> Bool
$c<= :: FMIndexT -> FMIndexT -> Bool
< :: FMIndexT -> FMIndexT -> Bool
$c< :: FMIndexT -> FMIndexT -> Bool
compare :: FMIndexT -> FMIndexT -> Ordering
$ccompare :: FMIndexT -> FMIndexT -> Ordering
Ord,Int -> FMIndexT -> ShowS
[FMIndexT] -> ShowS
FMIndexT -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FMIndexT] -> ShowS
$cshowList :: [FMIndexT] -> ShowS
show :: FMIndexT -> String
$cshow :: FMIndexT -> String
showsPrec :: Int -> FMIndexT -> ShowS
$cshowsPrec :: Int -> FMIndexT -> ShowS
Show,ReadPrec [FMIndexT]
ReadPrec FMIndexT
Int -> ReadS FMIndexT
ReadS [FMIndexT]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FMIndexT]
$creadListPrec :: ReadPrec [FMIndexT]
readPrec :: ReadPrec FMIndexT
$creadPrec :: ReadPrec FMIndexT
readList :: ReadS [FMIndexT]
$creadList :: ReadS [FMIndexT]
readsPrec :: Int -> ReadS FMIndexT
$creadsPrec :: Int -> ReadS FMIndexT
Read,forall x. Rep FMIndexT x -> FMIndexT
forall x. FMIndexT -> Rep FMIndexT x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FMIndexT x -> FMIndexT
$cfrom :: forall x. FMIndexT -> Rep FMIndexT x
Generic)

-- | Basic OccCKB ('ByteString') data type.
newtype OccCKB = OccCKB (Seq (Maybe ByteString,Seq (Int,Int,Maybe ByteString)))
  deriving (OccCKB -> OccCKB -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OccCKB -> OccCKB -> Bool
$c/= :: OccCKB -> OccCKB -> Bool
== :: OccCKB -> OccCKB -> Bool
$c== :: OccCKB -> OccCKB -> Bool
Eq,Eq OccCKB
OccCKB -> OccCKB -> Bool
OccCKB -> OccCKB -> Ordering
OccCKB -> OccCKB -> OccCKB
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 :: OccCKB -> OccCKB -> OccCKB
$cmin :: OccCKB -> OccCKB -> OccCKB
max :: OccCKB -> OccCKB -> OccCKB
$cmax :: OccCKB -> OccCKB -> OccCKB
>= :: OccCKB -> OccCKB -> Bool
$c>= :: OccCKB -> OccCKB -> Bool
> :: OccCKB -> OccCKB -> Bool
$c> :: OccCKB -> OccCKB -> Bool
<= :: OccCKB -> OccCKB -> Bool
$c<= :: OccCKB -> OccCKB -> Bool
< :: OccCKB -> OccCKB -> Bool
$c< :: OccCKB -> OccCKB -> Bool
compare :: OccCKB -> OccCKB -> Ordering
$ccompare :: OccCKB -> OccCKB -> Ordering
Ord,Int -> OccCKB -> ShowS
[OccCKB] -> ShowS
OccCKB -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OccCKB] -> ShowS
$cshowList :: [OccCKB] -> ShowS
show :: OccCKB -> String
$cshow :: OccCKB -> String
showsPrec :: Int -> OccCKB -> ShowS
$cshowsPrec :: Int -> OccCKB -> ShowS
Show,ReadPrec [OccCKB]
ReadPrec OccCKB
Int -> ReadS OccCKB
ReadS [OccCKB]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [OccCKB]
$creadListPrec :: ReadPrec [OccCKB]
readPrec :: ReadPrec OccCKB
$creadPrec :: ReadPrec OccCKB
readList :: ReadS [OccCKB]
$creadList :: ReadS [OccCKB]
readsPrec :: Int -> ReadS OccCKB
$creadsPrec :: Int -> ReadS OccCKB
Read,forall x. Rep OccCKB x -> OccCKB
forall x. OccCKB -> Rep OccCKB x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OccCKB x -> OccCKB
$cfrom :: forall x. OccCKB -> Rep OccCKB x
Generic)

-- | Basic OccCKT ('Text') data type.
newtype OccCKT = OccCKT (Seq (Maybe Text,Seq (Int,Int,Maybe Text)))
  deriving (OccCKT -> OccCKT -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OccCKT -> OccCKT -> Bool
$c/= :: OccCKT -> OccCKT -> Bool
== :: OccCKT -> OccCKT -> Bool
$c== :: OccCKT -> OccCKT -> Bool
Eq,Eq OccCKT
OccCKT -> OccCKT -> Bool
OccCKT -> OccCKT -> Ordering
OccCKT -> OccCKT -> OccCKT
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 :: OccCKT -> OccCKT -> OccCKT
$cmin :: OccCKT -> OccCKT -> OccCKT
max :: OccCKT -> OccCKT -> OccCKT
$cmax :: OccCKT -> OccCKT -> OccCKT
>= :: OccCKT -> OccCKT -> Bool
$c>= :: OccCKT -> OccCKT -> Bool
> :: OccCKT -> OccCKT -> Bool
$c> :: OccCKT -> OccCKT -> Bool
<= :: OccCKT -> OccCKT -> Bool
$c<= :: OccCKT -> OccCKT -> Bool
< :: OccCKT -> OccCKT -> Bool
$c< :: OccCKT -> OccCKT -> Bool
compare :: OccCKT -> OccCKT -> Ordering
$ccompare :: OccCKT -> OccCKT -> Ordering
Ord,Int -> OccCKT -> ShowS
[OccCKT] -> ShowS
OccCKT -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OccCKT] -> ShowS
$cshowList :: [OccCKT] -> ShowS
show :: OccCKT -> String
$cshow :: OccCKT -> String
showsPrec :: Int -> OccCKT -> ShowS
$cshowsPrec :: Int -> OccCKT -> ShowS
Show,ReadPrec [OccCKT]
ReadPrec OccCKT
Int -> ReadS OccCKT
ReadS [OccCKT]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [OccCKT]
$creadListPrec :: ReadPrec [OccCKT]
readPrec :: ReadPrec OccCKT
$creadPrec :: ReadPrec OccCKT
readList :: ReadS [OccCKT]
$creadList :: ReadS [OccCKT]
readsPrec :: Int -> ReadS OccCKT
$creadsPrec :: Int -> ReadS OccCKT
Read,forall x. Rep OccCKT x -> OccCKT
forall x. OccCKT -> Rep OccCKT x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OccCKT x -> OccCKT
$cfrom :: forall x. OccCKT -> Rep OccCKT x
Generic)

-- | Basic C[c] table ('ByteString') data type.
newtype CcB = CcB (Seq (Int,Maybe ByteString))
  deriving (CcB -> CcB -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CcB -> CcB -> Bool
$c/= :: CcB -> CcB -> Bool
== :: CcB -> CcB -> Bool
$c== :: CcB -> CcB -> Bool
Eq,Eq CcB
CcB -> CcB -> Bool
CcB -> CcB -> Ordering
CcB -> CcB -> CcB
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 :: CcB -> CcB -> CcB
$cmin :: CcB -> CcB -> CcB
max :: CcB -> CcB -> CcB
$cmax :: CcB -> CcB -> CcB
>= :: CcB -> CcB -> Bool
$c>= :: CcB -> CcB -> Bool
> :: CcB -> CcB -> Bool
$c> :: CcB -> CcB -> Bool
<= :: CcB -> CcB -> Bool
$c<= :: CcB -> CcB -> Bool
< :: CcB -> CcB -> Bool
$c< :: CcB -> CcB -> Bool
compare :: CcB -> CcB -> Ordering
$ccompare :: CcB -> CcB -> Ordering
Ord,Int -> CcB -> ShowS
[CcB] -> ShowS
CcB -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CcB] -> ShowS
$cshowList :: [CcB] -> ShowS
show :: CcB -> String
$cshow :: CcB -> String
showsPrec :: Int -> CcB -> ShowS
$cshowsPrec :: Int -> CcB -> ShowS
Show,ReadPrec [CcB]
ReadPrec CcB
Int -> ReadS CcB
ReadS [CcB]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CcB]
$creadListPrec :: ReadPrec [CcB]
readPrec :: ReadPrec CcB
$creadPrec :: ReadPrec CcB
readList :: ReadS [CcB]
$creadList :: ReadS [CcB]
readsPrec :: Int -> ReadS CcB
$creadsPrec :: Int -> ReadS CcB
Read,forall x. Rep CcB x -> CcB
forall x. CcB -> Rep CcB x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CcB x -> CcB
$cfrom :: forall x. CcB -> Rep CcB x
Generic)

-- | Basic C[c] table ('Text') data type.
newtype CcT = CcT (Seq (Int,Maybe Text))
  deriving (CcT -> CcT -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CcT -> CcT -> Bool
$c/= :: CcT -> CcT -> Bool
== :: CcT -> CcT -> Bool
$c== :: CcT -> CcT -> Bool
Eq,Eq CcT
CcT -> CcT -> Bool
CcT -> CcT -> Ordering
CcT -> CcT -> CcT
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 :: CcT -> CcT -> CcT
$cmin :: CcT -> CcT -> CcT
max :: CcT -> CcT -> CcT
$cmax :: CcT -> CcT -> CcT
>= :: CcT -> CcT -> Bool
$c>= :: CcT -> CcT -> Bool
> :: CcT -> CcT -> Bool
$c> :: CcT -> CcT -> Bool
<= :: CcT -> CcT -> Bool
$c<= :: CcT -> CcT -> Bool
< :: CcT -> CcT -> Bool
$c< :: CcT -> CcT -> Bool
compare :: CcT -> CcT -> Ordering
$ccompare :: CcT -> CcT -> Ordering
Ord,Int -> CcT -> ShowS
[CcT] -> ShowS
CcT -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CcT] -> ShowS
$cshowList :: [CcT] -> ShowS
show :: CcT -> String
$cshow :: CcT -> String
showsPrec :: Int -> CcT -> ShowS
$cshowsPrec :: Int -> CcT -> ShowS
Show,ReadPrec [CcT]
ReadPrec CcT
Int -> ReadS CcT
ReadS [CcT]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CcT]
$creadListPrec :: ReadPrec [CcT]
readPrec :: ReadPrec CcT
$creadPrec :: ReadPrec CcT
readList :: ReadS [CcT]
$creadList :: ReadS [CcT]
readsPrec :: Int -> ReadS CcT
$creadsPrec :: Int -> ReadS CcT
Read,forall x. Rep CcT x -> CcT
forall x. CcT -> Rep CcT x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CcT x -> CcT
$cfrom :: forall x. CcT -> Rep CcT x
Generic)

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


{-toOccCK (ByteString) functions.-}

-- | Abstract 'PBOccCKSeqB' type utilizing a 'Seq'.
type PBOccCKSeqB = Seq (Maybe ByteString)

-- | Abstract 'OccCKSeqB' type utilizing a 'Seq'.
-- (c,(indexofinputcurrentelement,Occ(c,k),inputcurrentelement))
type OccCKSeqB = Seq (Maybe ByteString,Seq (Int,Int,Maybe ByteString))

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

-- | State function to update 'OccCKSeqB'
-- with each step of the OccCK.
updateSTOccCKSeqAB :: STOccCKSeqB s (Seq (Maybe ByteString,Seq (Int,Int,Maybe ByteString)))
                   -> (Int,Int,Maybe ByteString)
                   -> ST s ()
updateSTOccCKSeqAB :: forall s.
STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> (Int, Int, Maybe ByteString) -> ST s ()
updateSTOccCKSeqAB STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
s (Int, Int, Maybe ByteString)
e = do
  Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2 <- forall s a. STRef s a -> ST s a
readSTRef STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
s
  case forall a. Seq a -> ViewR a
viewr Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2 of
    ViewR (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
EmptyR           -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
    (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2h DS.:> (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2fm) -> forall s a. STRef s a -> a -> ST s ()
writeSTRef STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2h forall a. Seq a -> a -> Seq a
DS.|> (((\(Maybe ByteString
a,Seq (Int, Int, Maybe ByteString)
_) -> Maybe ByteString
a) (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2fm),((\(Maybe ByteString
_,Seq (Int, Int, Maybe ByteString)
b) -> Seq (Int, Int, Maybe ByteString)
b) (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2fm) forall a. Seq a -> a -> Seq a
DS.|> (Int, Int, Maybe ByteString)
e))

-- | State function to update 'OccCKSeqB'
-- with each step of the OccCK.
updateSTOccCKSeqBB :: STOccCKSeqB s (Seq (Maybe ByteString,Seq (Int,Int,Maybe ByteString)))
                   -> Maybe ByteString
                   -> ST s ()
updateSTOccCKSeqBB :: forall s.
STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> Maybe ByteString -> ST s ()
updateSTOccCKSeqBB STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
s Maybe ByteString
e = do
  Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2 <- forall s a. STRef s a -> ST s a
readSTRef STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
s
  forall s a. STRef s a -> a -> ST s ()
writeSTRef STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2 forall a. Seq a -> a -> Seq a
DS.|> (Maybe ByteString
e,forall a. Seq a
DS.empty))

-- | State function to create empty 'STOccCKSeqB' type.
emptySTOccCKSeqB :: ST s (STOccCKSeqB s a)
emptySTOccCKSeqB :: forall s a. ST s (STOccCKSeqB s a)
emptySTOccCKSeqB = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Seq a
DS.empty

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

-- | State function to load list into 'STOccCKILB'.
loadSTOccCKILB :: STOccCKILB s (Maybe ByteString)
               -> Seq (Maybe ByteString)
               -> ST s ()
loadSTOccCKILB :: forall s.
STOccCKILB s (Maybe ByteString)
-> Seq (Maybe ByteString) -> ST s ()
loadSTOccCKILB STOccCKILB s (Maybe ByteString)
s Seq (Maybe ByteString)
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STOccCKILB s (Maybe ByteString)
s Seq (Maybe ByteString)
e

-- | State function to create empty 'STOccCKILB' type.
emptySTOccCKILB :: ST s (STOccCKILB s a)
emptySTOccCKILB :: forall s a. ST s (STOccCKILB s a)
emptySTOccCKILB = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Seq a
DS.empty

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

-- | State function to update 'STOccCKCounterB'.
updateSTOccCKCounterB :: STOccCKCounterB s Int
                        -> Int
                        -> ST s ()
updateSTOccCKCounterB :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterB STOccCKCounterB s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STOccCKCounterB s Int
s Int
e

-- | State function to create empty 'STOccCKCounterB' type.
emptySTOccCKCounterB :: ST s (STOccCKCounterB s Int)
emptySTOccCKCounterB :: forall s. ST s (STOccCKCounterB s Int)
emptySTOccCKCounterB = forall a s. a -> ST s (STRef s a)
newSTRef Int
0 

-- | Strict state monad function.
seqToOccCKB :: PBOccCKSeqB
            -> ST s OccCKSeqB
seqToOccCKB :: forall s.
Seq (Maybe ByteString)
-> ST s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
seqToOccCKB Seq (Maybe ByteString)
DS.Empty      = do
  STOccCKSeqB s Any
boccckseqstackempty  <- forall s a. ST s (STOccCKSeqB s a)
emptySTOccCKSeqB
  Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
boccckseqstackemptyr <- forall s a. STRef s a -> ST s a
readSTRef STOccCKSeqB s Any
boccckseqstackempty
  forall (m :: * -> *) a. Monad m => a -> m a
return Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
boccckseqstackemptyr
seqToOccCKB Seq (Maybe ByteString)
xs            = do
  STOccCKSeqB s Any
boccckseqstack     <- forall s a. ST s (STOccCKSeqB s a)
emptySTOccCKSeqB 
  STOccCKILB s Any
boccckinitiallist  <- forall s a. ST s (STOccCKILB s a)
emptySTOccCKILB
  STOccCKCounterB s Int
boccckcounterstack <- forall s. ST s (STOccCKCounterB s Int)
emptySTOccCKCounterB
  let il :: Seq (Maybe ByteString)
il = forall a. Ord a => Seq (Maybe a) -> Seq (Maybe a)
nubSeq' Seq (Maybe ByteString)
xs
  forall s.
STOccCKILB s (Maybe ByteString)
-> Seq (Maybe ByteString) -> ST s ()
loadSTOccCKILB STOccCKILB s Any
boccckinitiallist
                 Seq (Maybe ByteString)
il
  Seq (Maybe ByteString)
cboccckinitiallist <- forall s a. STRef s a -> ST s a
readSTRef STOccCKILB s Any
boccckinitiallist
  forall {s}.
Seq (Maybe ByteString)
-> Seq (Maybe ByteString)
-> STOccCKSeqB
     s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> STOccCKCounterB s Int
-> ST s ()
iOccCKB Seq (Maybe ByteString)
cboccckinitiallist
          Seq (Maybe ByteString)
xs
          STOccCKSeqB s Any
boccckseqstack
          STOccCKCounterB s Int
boccckcounterstack
  Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
boccckseqstackr <- forall s a. STRef s a -> ST s a
readSTRef STOccCKSeqB s Any
boccckseqstack
  forall (m :: * -> *) a. Monad m => a -> m a
return Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
boccckseqstackr
    where
      iOccCKB :: Seq (Maybe ByteString)
-> Seq (Maybe ByteString)
-> STOccCKSeqB
     s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> STOccCKCounterB s Int
-> ST s ()
iOccCKB Seq (Maybe ByteString)
DS.Empty      Seq (Maybe ByteString)
_      STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
_        STOccCKCounterB s Int
_        = forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
      iOccCKB (Maybe ByteString
y DS.:<| Seq (Maybe ByteString)
ys) Seq (Maybe ByteString)
zs     STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss STOccCKCounterB s Int
boccckcs = do
        STOccCKCounterB s Int
boccckis <- forall s. ST s (STOccCKCounterB s Int)
emptySTOccCKCounterB
        forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterB STOccCKCounterB s Int
boccckis
                              Int
1
        forall s.
STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> Maybe ByteString -> ST s ()
updateSTOccCKSeqBB STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss
                           Maybe ByteString
y
        forall {s}.
Maybe ByteString
-> Seq (Maybe ByteString)
-> STOccCKSeqB
     s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> STRef s Int
-> STRef s Int
-> ST s ()
iiOccCKB Maybe ByteString
y
                 Seq (Maybe ByteString)
zs
                 STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss
                 STOccCKCounterB s Int
boccckis
                 STOccCKCounterB s Int
boccckcs                           
        Seq (Maybe ByteString)
-> Seq (Maybe ByteString)
-> STOccCKSeqB
     s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> STOccCKCounterB s Int
-> ST s ()
iOccCKB Seq (Maybe ByteString)
ys
                Seq (Maybe ByteString)
zs
                STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss
                STOccCKCounterB s Int
boccckcs
      iiOccCKB :: Maybe ByteString
-> Seq (Maybe ByteString)
-> STOccCKSeqB
     s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> STRef s Int
-> STRef s Int
-> ST s ()
iiOccCKB Maybe ByteString
_  Seq (Maybe ByteString)
DS.Empty      STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
_        STRef s Int
_        STRef s Int
boccckcs = do
        forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterB STRef s Int
boccckcs
                              Int
0
        forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
      iiOccCKB Maybe ByteString
as (Maybe ByteString
b DS.:<| Seq (Maybe ByteString)
bs) STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss STRef s Int
boccckis STRef s Int
boccckcs = do
        Int
cboccckis <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
boccckis
        Int
cboccckcs <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
boccckcs
        if | Maybe ByteString
as forall a. Eq a => a -> a -> Bool
== Maybe ByteString
b
           -> do forall s.
STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> (Int, Int, Maybe ByteString) -> ST s ()
updateSTOccCKSeqAB STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss
                                    (Int
cboccckis,Int
cboccckcs forall a. Num a => a -> a -> a
+ Int
1,Maybe ByteString
b)
                 forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterB STRef s Int
boccckcs
                                       (Int
cboccckcs forall a. Num a => a -> a -> a
+ Int
1)
                 forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterB STRef s Int
boccckis
                                       (Int
cboccckis forall a. Num a => a -> a -> a
+ Int
1)
                 Maybe ByteString
-> Seq (Maybe ByteString)
-> STOccCKSeqB
     s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> STRef s Int
-> STRef s Int
-> ST s ()
iiOccCKB Maybe ByteString
as
                          Seq (Maybe ByteString)
bs
                          STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss
                          STRef s Int
boccckis
                          STRef s Int
boccckcs    
           | Bool
otherwise
           -> do forall s.
STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> (Int, Int, Maybe ByteString) -> ST s ()
updateSTOccCKSeqAB STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss
                                    (Int
cboccckis,Int
cboccckcs,Maybe ByteString
b)
                 forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterB STRef s Int
boccckis
                                       (Int
cboccckis forall a. Num a => a -> a -> a
+ Int
1)
                 Maybe ByteString
-> Seq (Maybe ByteString)
-> STOccCKSeqB
     s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> STRef s Int
-> STRef s Int
-> ST s ()
iiOccCKB Maybe ByteString
as
                          Seq (Maybe ByteString)
bs
                          STOccCKSeqB
  s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss
                          STRef s Int
boccckis
                          STRef s Int
boccckcs

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


{-toOccCK (Text) functions.-}

-- | Abstract 'PTOccCKSeqT' type utilizing a 'Seq'.
type PTOccCKSeqT = Seq (Maybe Text)

-- | Abstract 'OccCKSeqT' type utilizing a 'Seq'.
-- (c,(indexofinputcurrentelement,Occ(c,k),inputcurrentelement))
type OccCKSeqT = Seq (Maybe Text,Seq (Int,Int,Maybe Text))

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

-- | State function to update 'OccCKSeqT'
-- with each step of the OccCK.
updateSTOccCKSeqAT :: STOccCKSeqT s (Seq (Maybe Text,Seq (Int,Int,Maybe Text)))
                   -> (Int,Int,Maybe Text)
                   -> ST s ()
updateSTOccCKSeqAT :: forall s.
STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> (Int, Int, Maybe Text) -> ST s ()
updateSTOccCKSeqAT STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
s (Int, Int, Maybe Text)
e = do
  Seq (Maybe Text, Seq (Int, Int, Maybe Text))
s2 <- forall s a. STRef s a -> ST s a
readSTRef STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
s
  case forall a. Seq a -> ViewR a
viewr Seq (Maybe Text, Seq (Int, Int, Maybe Text))
s2 of
    ViewR (Maybe Text, Seq (Int, Int, Maybe Text))
EmptyR           -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
    (Seq (Maybe Text, Seq (Int, Int, Maybe Text))
s2h DS.:> (Maybe Text, Seq (Int, Int, Maybe Text))
s2fm) -> forall s a. STRef s a -> a -> ST s ()
writeSTRef STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
s (Seq (Maybe Text, Seq (Int, Int, Maybe Text))
s2h forall a. Seq a -> a -> Seq a
DS.|> (((\(Maybe Text
a,Seq (Int, Int, Maybe Text)
_) -> Maybe Text
a) (Maybe Text, Seq (Int, Int, Maybe Text))
s2fm),((\(Maybe Text
_,Seq (Int, Int, Maybe Text)
b) -> Seq (Int, Int, Maybe Text)
b) (Maybe Text, Seq (Int, Int, Maybe Text))
s2fm) forall a. Seq a -> a -> Seq a
DS.|> (Int, Int, Maybe Text)
e))

-- | State function to update 'OccCKSeqT'
-- with each step of the OccCK.
updateSTOccCKSeqBT :: STOccCKSeqT s (Seq (Maybe Text,Seq (Int,Int,Maybe Text)))
                   -> Maybe Text
                   -> ST s ()
updateSTOccCKSeqBT :: forall s.
STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> Maybe Text -> ST s ()
updateSTOccCKSeqBT STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
s Maybe Text
e = do
  Seq (Maybe Text, Seq (Int, Int, Maybe Text))
s2 <- forall s a. STRef s a -> ST s a
readSTRef STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
s
  forall s a. STRef s a -> a -> ST s ()
writeSTRef STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
s (Seq (Maybe Text, Seq (Int, Int, Maybe Text))
s2 forall a. Seq a -> a -> Seq a
DS.|> (Maybe Text
e,forall a. Seq a
DS.empty))

-- | State function to create empty 'STOccCKSeqT' type.
emptySTOccCKSeqT :: ST s (STOccCKSeqT s a)
emptySTOccCKSeqT :: forall s a. ST s (STOccCKSeqT s a)
emptySTOccCKSeqT = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Seq a
DS.empty

-- | Abstract 'STOccCKILT' and associated state type.
type STOccCKILT s a = STRef s (Seq (Maybe Text))

-- | State function to load list into 'STOccCKILT'.
loadSTOccCKILT :: STOccCKILT s (Maybe Text)
               -> Seq (Maybe Text)
               -> ST s ()
loadSTOccCKILT :: forall s. STOccCKILT s (Maybe Text) -> Seq (Maybe Text) -> ST s ()
loadSTOccCKILT STOccCKILT s (Maybe Text)
s Seq (Maybe Text)
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STOccCKILT s (Maybe Text)
s Seq (Maybe Text)
e

-- | State function to create empty 'STOccCKILT' type.
emptySTOccCKILT :: ST s (STOccCKILT s a)
emptySTOccCKILT :: forall s a. ST s (STOccCKILT s a)
emptySTOccCKILT = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Seq a
DS.empty

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

-- | State function to update 'STOccCKCounterT'.
updateSTOccCKCounterT :: STOccCKCounterT s Int
                      -> Int
                      -> ST s ()
updateSTOccCKCounterT :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterT STOccCKCounterT s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STOccCKCounterT s Int
s Int
e

-- | State function to create empty 'STOccCKCounterT' type.
emptySTOccCKCounterT :: ST s (STOccCKCounterT s Int)
emptySTOccCKCounterT :: forall s. ST s (STOccCKCounterB s Int)
emptySTOccCKCounterT = forall a s. a -> ST s (STRef s a)
newSTRef Int
0

-- | Strict state monad function.
seqToOccCKT :: PTOccCKSeqT
            -> ST s OccCKSeqT
seqToOccCKT :: forall s.
Seq (Maybe Text)
-> ST s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
seqToOccCKT Seq (Maybe Text)
DS.Empty      = do
  STOccCKSeqT s Any
toccckseqstackempty  <- forall s a. ST s (STOccCKSeqT s a)
emptySTOccCKSeqT
  Seq (Maybe Text, Seq (Int, Int, Maybe Text))
toccckseqstackemptyr <- forall s a. STRef s a -> ST s a
readSTRef STOccCKSeqT s Any
toccckseqstackempty
  forall (m :: * -> *) a. Monad m => a -> m a
return Seq (Maybe Text, Seq (Int, Int, Maybe Text))
toccckseqstackemptyr
seqToOccCKT Seq (Maybe Text)
xs            = do
  STOccCKSeqT s Any
toccckseqstack     <- forall s a. ST s (STOccCKSeqT s a)
emptySTOccCKSeqT
  STOccCKILT s Any
toccckinitiallist  <- forall s a. ST s (STOccCKILT s a)
emptySTOccCKILT
  STOccCKCounterT s Int
toccckcounterstack <- forall s. ST s (STOccCKCounterB s Int)
emptySTOccCKCounterT
  let il :: Seq (Maybe Text)
il = forall a. Ord a => Seq (Maybe a) -> Seq (Maybe a)
nubSeq' Seq (Maybe Text)
xs
  forall s. STOccCKILT s (Maybe Text) -> Seq (Maybe Text) -> ST s ()
loadSTOccCKILT STOccCKILT s Any
toccckinitiallist
                 Seq (Maybe Text)
il
  Seq (Maybe Text)
ctoccckinitiallist <- forall s a. STRef s a -> ST s a
readSTRef STOccCKILT s Any
toccckinitiallist
  forall {s}.
Seq (Maybe Text)
-> Seq (Maybe Text)
-> STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> STOccCKCounterT s Int
-> ST s ()
iOccCKT Seq (Maybe Text)
ctoccckinitiallist
          Seq (Maybe Text)
xs
          STOccCKSeqT s Any
toccckseqstack
          STOccCKCounterT s Int
toccckcounterstack
  Seq (Maybe Text, Seq (Int, Int, Maybe Text))
toccckseqstackr <- forall s a. STRef s a -> ST s a
readSTRef STOccCKSeqT s Any
toccckseqstack
  forall (m :: * -> *) a. Monad m => a -> m a
return Seq (Maybe Text, Seq (Int, Int, Maybe Text))
toccckseqstackr
    where
      iOccCKT :: Seq (Maybe Text)
-> Seq (Maybe Text)
-> STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> STOccCKCounterT s Int
-> ST s ()
iOccCKT Seq (Maybe Text)
DS.Empty      Seq (Maybe Text)
_      STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
_        STOccCKCounterT s Int
_        = forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
      iOccCKT (Maybe Text
y DS.:<| Seq (Maybe Text)
ys) Seq (Maybe Text)
zs     STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss STOccCKCounterT s Int
toccckcs = do
        STOccCKCounterT s Int
toccckis <- forall s. ST s (STOccCKCounterB s Int)
emptySTOccCKCounterT
        forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterT STOccCKCounterT s Int
toccckis
                              Int
1
        forall s.
STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> Maybe Text -> ST s ()
updateSTOccCKSeqBT STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss
                           Maybe Text
y
        forall {s}.
Maybe Text
-> Seq (Maybe Text)
-> STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> STRef s Int
-> STRef s Int
-> ST s ()
iiOccCKT Maybe Text
y
                 Seq (Maybe Text)
zs
                 STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss
                 STOccCKCounterT s Int
toccckis
                 STOccCKCounterT s Int
toccckcs
        Seq (Maybe Text)
-> Seq (Maybe Text)
-> STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> STOccCKCounterT s Int
-> ST s ()
iOccCKT Seq (Maybe Text)
ys
                Seq (Maybe Text)
zs
                STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss
                STOccCKCounterT s Int
toccckcs
      iiOccCKT :: Maybe Text
-> Seq (Maybe Text)
-> STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> STRef s Int
-> STRef s Int
-> ST s ()
iiOccCKT Maybe Text
_  Seq (Maybe Text)
DS.Empty      STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
_        STRef s Int
_        STRef s Int
toccckcs = do
        forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterT STRef s Int
toccckcs
                              Int
0
        forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
      iiOccCKT Maybe Text
as (Maybe Text
b DS.:<| Seq (Maybe Text)
bs) STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss STRef s Int
toccckis STRef s Int
toccckcs = do
        Int
ctoccckis <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
toccckis
        Int
ctoccckcs <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
toccckcs
        if | Maybe Text
as forall a. Eq a => a -> a -> Bool
== Maybe Text
b
           -> do forall s.
STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> (Int, Int, Maybe Text) -> ST s ()
updateSTOccCKSeqAT STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss
                                    (Int
ctoccckis,Int
ctoccckcs forall a. Num a => a -> a -> a
+ Int
1,Maybe Text
b)
                 forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterT STRef s Int
toccckcs
                                       (Int
ctoccckcs forall a. Num a => a -> a -> a
+ Int
1)
                 forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterT STRef s Int
toccckis
                                       (Int
ctoccckis forall a. Num a => a -> a -> a
+ Int
1)
                 Maybe Text
-> Seq (Maybe Text)
-> STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> STRef s Int
-> STRef s Int
-> ST s ()
iiOccCKT Maybe Text
as
                          Seq (Maybe Text)
bs
                          STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss
                          STRef s Int
toccckis
                          STRef s Int
toccckcs
           | Bool
otherwise
           -> do forall s.
STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> (Int, Int, Maybe Text) -> ST s ()
updateSTOccCKSeqAT STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss
                                    (Int
ctoccckis,Int
ctoccckcs,Maybe Text
b)
                 forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterT STRef s Int
toccckis
                                       (Int
ctoccckis forall a. Num a => a -> a -> a
+ Int
1)
                 Maybe Text
-> Seq (Maybe Text)
-> STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> STRef s Int
-> STRef s Int
-> ST s ()
iiOccCKT Maybe Text
as
                          Seq (Maybe Text)
bs
                          STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss
                          STRef s Int
toccckis
                          STRef s Int
toccckcs

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


{-To Cc (ByteString) functions.-}

-- | Abstract 'PBCcSeqB' type utilizing a 'Seq'.
type PBCcSeqB = Seq (Maybe ByteString)

-- | Abstract 'CcSeqB' type utilizing a 'Seq'.
-- (C[c],c)
type CcSeqB = Seq (Int,Maybe ByteString)

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

-- | State function to update 'CcSeqB'
-- with each step of the C[c].
updateSTCcSeqB :: STCcSeqB s (Seq (Int,Maybe ByteString))
               -> (Int,Maybe ByteString)
               -> ST s ()
updateSTCcSeqB :: forall s.
STCcSeqB s (Seq (Int, Maybe ByteString))
-> (Int, Maybe ByteString) -> ST s ()
updateSTCcSeqB STCcSeqB s (Seq (Int, Maybe ByteString))
s (Int, Maybe ByteString)
e = do
  Seq (Int, Maybe ByteString)
s2 <- forall s a. STRef s a -> ST s a
readSTRef STCcSeqB s (Seq (Int, Maybe ByteString))
s
  forall s a. STRef s a -> a -> ST s ()
writeSTRef STCcSeqB s (Seq (Int, Maybe ByteString))
s (Seq (Int, Maybe ByteString)
s2 forall a. Seq a -> a -> Seq a
DS.|> (Int, Maybe ByteString)
e)

-- | State function to create empty 'STCcSeqT' type.
emptySTCcSeqB :: ST s (STCcSeqB s a)
emptySTCcSeqB :: forall s a. ST s (STCcSeqB s a)
emptySTCcSeqB = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Seq a
DS.empty

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

-- | State function to load list into 'STCcILB'.
loadSTCcILB :: STCcILB s (Maybe ByteString)
            -> Seq (Maybe ByteString)
            -> ST s ()
loadSTCcILB :: forall s.
STOccCKILB s (Maybe ByteString)
-> Seq (Maybe ByteString) -> ST s ()
loadSTCcILB STCcILB s (Maybe ByteString)
s Seq (Maybe ByteString)
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STCcILB s (Maybe ByteString)
s Seq (Maybe ByteString)
e

-- | State function to create empty 'STCcILB' type.
emptySTCcILB :: ST s (STCcILB s a)
emptySTCcILB :: forall s a. ST s (STOccCKILB s a)
emptySTCcILB = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Seq a
DS.empty

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

-- | State function to update 'STCcCounterB'.
updateSTCcCounterB :: STCcCounterB s Int
                   -> Int
                   -> ST s ()
updateSTCcCounterB :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCcCounterB STCcCounterB s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STCcCounterB s Int
s Int
e

-- | State function to create empty 'STCcCounterT' type.
emptySTCcCounterB :: ST s (STCcCounterB s Int)
emptySTCcCounterB :: forall s. ST s (STOccCKCounterB s Int)
emptySTCcCounterB = forall a s. a -> ST s (STRef s a)
newSTRef Int
0

-- | Strict state monad function.
seqToCcB :: PBCcSeqB
         -> ST s CcSeqB
seqToCcB :: forall s.
Seq (Maybe ByteString) -> ST s (Seq (Int, Maybe ByteString))
seqToCcB Seq (Maybe ByteString)
DS.Empty      = do
  STCcSeqB s Any
bccseqstackempty  <- forall s a. ST s (STCcSeqB s a)
emptySTCcSeqB
  Seq (Int, Maybe ByteString)
bccseqstackemptyr <- forall s a. STRef s a -> ST s a
readSTRef STCcSeqB s Any
bccseqstackempty
  forall (m :: * -> *) a. Monad m => a -> m a
return Seq (Int, Maybe ByteString)
bccseqstackemptyr
seqToCcB Seq (Maybe ByteString)
xs            = do
  STCcSeqB s Any
bccseqstack     <- forall s a. ST s (STCcSeqB s a)
emptySTCcSeqB
  STCcILB s Any
bccinitiallist  <- forall s a. ST s (STOccCKILB s a)
emptySTCcILB
  STCcCounterB s Int
bcccounterstack <- forall s. ST s (STOccCKCounterB s Int)
emptySTCcCounterB
  let il :: Seq (Maybe ByteString)
il = forall a. Ord a => Seq (Maybe a) -> Seq (Maybe a)
nubSeq' Seq (Maybe ByteString)
xs
  forall s.
STOccCKILB s (Maybe ByteString)
-> Seq (Maybe ByteString) -> ST s ()
loadSTCcILB STCcILB s Any
bccinitiallist
              Seq (Maybe ByteString)
il
  Seq (Maybe ByteString)
cbccinitiallist <- forall s a. STRef s a -> ST s a
readSTRef STCcILB s Any
bccinitiallist
  forall {s}.
Seq (Maybe ByteString)
-> Seq (Maybe ByteString)
-> STCcSeqB s (Seq (Int, Maybe ByteString))
-> STCcCounterB s Int
-> ST s ()
iCcB Seq (Maybe ByteString)
cbccinitiallist
       Seq (Maybe ByteString)
xs
       STCcSeqB s Any
bccseqstack
       STCcCounterB s Int
bcccounterstack
  Seq (Int, Maybe ByteString)
bccseqstackr <- forall s a. STRef s a -> ST s a
readSTRef STCcSeqB s Any
bccseqstack
  forall (m :: * -> *) a. Monad m => a -> m a
return Seq (Int, Maybe ByteString)
bccseqstackr
    where
      iCcB :: Seq (Maybe ByteString)
-> Seq (Maybe ByteString)
-> STCcSeqB s (Seq (Int, Maybe ByteString))
-> STCcCounterB s Int
-> ST s ()
iCcB Seq (Maybe ByteString)
DS.Empty      Seq (Maybe ByteString)
_      STCcSeqB s (Seq (Int, Maybe ByteString))
_        STCcCounterB s Int
_  = forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
      iCcB (Maybe ByteString
y DS.:<| Seq (Maybe ByteString)
ys) Seq (Maybe ByteString)
zs     STCcSeqB s (Seq (Int, Maybe ByteString))
bccss STCcCounterB s Int
bcccs = do
        forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCcCounterB STCcCounterB s Int
bcccs
                           Int
0
        forall {s}.
Maybe ByteString
-> Seq (Maybe ByteString)
-> STCcSeqB s (Seq (Int, Maybe ByteString))
-> STRef s Int
-> ST s ()
iiCcB Maybe ByteString
y
              Seq (Maybe ByteString)
zs
              STCcSeqB s (Seq (Int, Maybe ByteString))
bccss
              STCcCounterB s Int
bcccs
        Seq (Maybe ByteString)
-> Seq (Maybe ByteString)
-> STCcSeqB s (Seq (Int, Maybe ByteString))
-> STCcCounterB s Int
-> ST s ()
iCcB Seq (Maybe ByteString)
ys
             Seq (Maybe ByteString)
zs
             STCcSeqB s (Seq (Int, Maybe ByteString))
bccss
             STCcCounterB s Int
bcccs
      iiCcB :: Maybe ByteString
-> Seq (Maybe ByteString)
-> STCcSeqB s (Seq (Int, Maybe ByteString))
-> STRef s Int
-> ST s ()
iiCcB Maybe ByteString
_  Seq (Maybe ByteString)
DS.Empty      STCcSeqB s (Seq (Int, Maybe ByteString))
_     STRef s Int
_     = forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
      iiCcB Maybe ByteString
as (Maybe ByteString
b DS.:<| Seq (Maybe ByteString)
bs) STCcSeqB s (Seq (Int, Maybe ByteString))
bccss STRef s Int
bcccs = do
        Int
cbcccs <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
bcccs
        if | Maybe ByteString
as forall a. Eq a => a -> a -> Bool
== Maybe ByteString
b
           -> forall s.
STCcSeqB s (Seq (Int, Maybe ByteString))
-> (Int, Maybe ByteString) -> ST s ()
updateSTCcSeqB STCcSeqB s (Seq (Int, Maybe ByteString))
bccss
                             (Int
cbcccs,Maybe ByteString
as) 
           | Bool
otherwise
           -> do forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCcCounterB STRef s Int
bcccs
                                    (Int
cbcccs forall a. Num a => a -> a -> a
+ Int
1)
                 Maybe ByteString
-> Seq (Maybe ByteString)
-> STCcSeqB s (Seq (Int, Maybe ByteString))
-> STRef s Int
-> ST s ()
iiCcB Maybe ByteString
as
                       Seq (Maybe ByteString)
bs
                       STCcSeqB s (Seq (Int, Maybe ByteString))
bccss 
                       STRef s Int
bcccs

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


{-To Cc (Text) functions.-}

-- | Abstract 'PTCcSeqT' type utilizing a 'Seq'.
type PTCcSeqT = Seq (Maybe Text)

-- | Abstract 'CcSeqT' type utilizing a 'Seq'.
-- (C[c],c)
type CcSeqT = Seq (Int,Maybe Text)

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

-- | State function to update 'CcSeqT'
-- with each step of the C[c].
updateSTCcSeqT :: STCcSeqT s (Seq (Int,Maybe Text))
               -> (Int,Maybe Text)
               -> ST s ()
updateSTCcSeqT :: forall s.
STCcSeqT s (Seq (Int, Maybe Text)) -> (Int, Maybe Text) -> ST s ()
updateSTCcSeqT STCcSeqT s (Seq (Int, Maybe Text))
s (Int, Maybe Text)
e = do
  Seq (Int, Maybe Text)
s2 <- forall s a. STRef s a -> ST s a
readSTRef STCcSeqT s (Seq (Int, Maybe Text))
s
  forall s a. STRef s a -> a -> ST s ()
writeSTRef STCcSeqT s (Seq (Int, Maybe Text))
s (Seq (Int, Maybe Text)
s2 forall a. Seq a -> a -> Seq a
DS.|> (Int, Maybe Text)
e)

-- | State function to create empty 'STCcSeqT' type.
emptySTCcSeqT :: ST s (STCcSeqT s a)
emptySTCcSeqT :: forall s a. ST s (STCcSeqT s a)
emptySTCcSeqT = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Seq a
DS.empty

-- | Abstract 'STCcILT' and associated state type.
type STCcILT s a = STRef s (Seq (Maybe Text))

-- | State function to load list into 'STCcILT'.
loadSTCcILT :: STCcILT s (Maybe Text)
            -> Seq (Maybe Text)
            -> ST s ()
loadSTCcILT :: forall s. STOccCKILT s (Maybe Text) -> Seq (Maybe Text) -> ST s ()
loadSTCcILT STCcILT s (Maybe Text)
s Seq (Maybe Text)
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STCcILT s (Maybe Text)
s Seq (Maybe Text)
e

-- | State function to create empty 'STCcILT' type.
emptySTCcILT :: ST s (STCcILT s a)
emptySTCcILT :: forall s a. ST s (STOccCKILT s a)
emptySTCcILT = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Seq a
DS.empty

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

-- | State function to update 'STCcCounterT'.
updateSTCcCounterT :: STCcCounterT s Int
                   -> Int
                   -> ST s ()
updateSTCcCounterT :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCcCounterT STCcCounterT s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STCcCounterT s Int
s Int
e

-- | State function to create empty 'STCcCounterT' type.
emptySTCcCounterT :: ST s (STCcCounterT s Int)
emptySTCcCounterT :: forall s. ST s (STOccCKCounterB s Int)
emptySTCcCounterT = forall a s. a -> ST s (STRef s a)
newSTRef Int
0

-- | Strict state monad function.
seqToCcT :: PTCcSeqT
         -> ST s CcSeqT
seqToCcT :: forall s. Seq (Maybe Text) -> ST s (Seq (Int, Maybe Text))
seqToCcT Seq (Maybe Text)
DS.Empty      = do
  STCcSeqT s Any
tccseqstackempty  <- forall s a. ST s (STCcSeqT s a)
emptySTCcSeqT
  Seq (Int, Maybe Text)
tccseqstackemptyr <- forall s a. STRef s a -> ST s a
readSTRef STCcSeqT s Any
tccseqstackempty
  forall (m :: * -> *) a. Monad m => a -> m a
return Seq (Int, Maybe Text)
tccseqstackemptyr
seqToCcT Seq (Maybe Text)
xs            = do
  STCcSeqT s Any
tccseqstack     <- forall s a. ST s (STCcSeqT s a)
emptySTCcSeqT
  STCcILT s Any
tccinitiallist  <- forall s a. ST s (STOccCKILT s a)
emptySTCcILT
  STCcCounterT s Int
tcccounterstack <- forall s. ST s (STOccCKCounterB s Int)
emptySTCcCounterT
  let il :: Seq (Maybe Text)
il = forall a. Ord a => Seq (Maybe a) -> Seq (Maybe a)
nubSeq' Seq (Maybe Text)
xs
  forall s. STOccCKILT s (Maybe Text) -> Seq (Maybe Text) -> ST s ()
loadSTCcILT STCcILT s Any
tccinitiallist
              Seq (Maybe Text)
il
  Seq (Maybe Text)
ctccinitiallist <- forall s a. STRef s a -> ST s a
readSTRef STCcILT s Any
tccinitiallist
  forall {s}.
Seq (Maybe Text)
-> Seq (Maybe Text)
-> STCcSeqT s (Seq (Int, Maybe Text))
-> STCcCounterT s Int
-> ST s ()
iCcT Seq (Maybe Text)
ctccinitiallist
       Seq (Maybe Text)
xs
       STCcSeqT s Any
tccseqstack
       STCcCounterT s Int
tcccounterstack
  Seq (Int, Maybe Text)
tccseqstackr <- forall s a. STRef s a -> ST s a
readSTRef STCcSeqT s Any
tccseqstack
  forall (m :: * -> *) a. Monad m => a -> m a
return Seq (Int, Maybe Text)
tccseqstackr
    where
      iCcT :: Seq (Maybe Text)
-> Seq (Maybe Text)
-> STCcSeqT s (Seq (Int, Maybe Text))
-> STCcCounterT s Int
-> ST s ()
iCcT Seq (Maybe Text)
DS.Empty      Seq (Maybe Text)
_      STCcSeqT s (Seq (Int, Maybe Text))
_        STCcCounterT s Int
_  = forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
      iCcT (Maybe Text
y DS.:<| Seq (Maybe Text)
ys) Seq (Maybe Text)
zs     STCcSeqT s (Seq (Int, Maybe Text))
tccss STCcCounterT s Int
tcccs = do
        forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCcCounterT STCcCounterT s Int
tcccs
                           Int
0
        forall {s}.
Maybe Text
-> Seq (Maybe Text)
-> STCcSeqT s (Seq (Int, Maybe Text))
-> STRef s Int
-> ST s ()
iiCcT Maybe Text
y
              Seq (Maybe Text)
zs
              STCcSeqT s (Seq (Int, Maybe Text))
tccss
              STCcCounterT s Int
tcccs
        Seq (Maybe Text)
-> Seq (Maybe Text)
-> STCcSeqT s (Seq (Int, Maybe Text))
-> STCcCounterT s Int
-> ST s ()
iCcT Seq (Maybe Text)
ys
             Seq (Maybe Text)
zs
             STCcSeqT s (Seq (Int, Maybe Text))
tccss
             STCcCounterT s Int
tcccs
      iiCcT :: Maybe Text
-> Seq (Maybe Text)
-> STCcSeqT s (Seq (Int, Maybe Text))
-> STRef s Int
-> ST s ()
iiCcT Maybe Text
_  Seq (Maybe Text)
DS.Empty      STCcSeqT s (Seq (Int, Maybe Text))
_     STRef s Int
_     = forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
      iiCcT Maybe Text
as (Maybe Text
b DS.:<| Seq (Maybe Text)
bs) STCcSeqT s (Seq (Int, Maybe Text))
tccss STRef s Int
tcccs = do
        Int
ctcccs <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
tcccs
        if | Maybe Text
as forall a. Eq a => a -> a -> Bool
== Maybe Text
b
           -> forall s.
STCcSeqT s (Seq (Int, Maybe Text)) -> (Int, Maybe Text) -> ST s ()
updateSTCcSeqT STCcSeqT s (Seq (Int, Maybe Text))
tccss
                             (Int
ctcccs,Maybe Text
as)
           | Bool
otherwise
           -> do forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCcCounterT STRef s Int
tcccs
                                    (Int
ctcccs forall a. Num a => a -> a -> a
+ Int
1)
                 Maybe Text
-> Seq (Maybe Text)
-> STCcSeqT s (Seq (Int, Maybe Text))
-> STRef s Int
-> ST s ()
iiCcT Maybe Text
as
                       Seq (Maybe Text)
bs
                       STCcSeqT s (Seq (Int, Maybe Text))
tccss
                       STRef s Int
tcccs

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


{-fromFMIndex (ByteString) functions.-}

-- | Abstract 'FFMIndexSeqB' type utilizing a 'Seq'.
type FFMIndexSeqB = Seq (Maybe ByteString)

-- | Simple Inverse FMIndex function. 
seqFromFMIndexB :: FMIndexB
                -> FFMIndexSeqB
seqFromFMIndexB :: FMIndexB -> Seq (Maybe ByteString)
seqFromFMIndexB (FMIndexB (CcB Seq (Int, Maybe ByteString)
DS.Empty,OccCKB
_))    = forall a. Seq a
DS.Empty
seqFromFMIndexB (FMIndexB (CcB
_,OccCKB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
DS.Empty)) = forall a. Seq a
DS.Empty
seqFromFMIndexB FMIndexB
xs                             = do
  let xss :: Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
xss = (\(OccCKB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
b) -> Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
b) forall a b. (a -> b) -> a -> b
$
            (\(CcB
_,OccCKB
b) -> OccCKB
b)      forall a b. (a -> b) -> a -> b
$
            (\(FMIndexB (CcB, OccCKB)
b) -> (CcB, OccCKB)
b) FMIndexB
xs
  forall {a} {a} {b} {a}. Seq (a, Seq (a, b, a)) -> Seq a
iFFMIndexB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
xss
    where
      iFFMIndexB :: Seq (a, Seq (a, b, a)) -> Seq a
iFFMIndexB Seq (a, Seq (a, b, a))
DS.Empty         = forall a. Seq a
DS.Empty 
      iFFMIndexB ((a
_,Seq (a, b, a)
b) DS.:<| Seq (a, Seq (a, b, a))
_) =
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(a
_,b
_,a
e) -> a
e) Seq (a, b, a)
b

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


{-fromFMIndex (Text) functions.-}

-- | Abstract 'FFMIndexSeqT' type utilizing a 'Seq'.
type FFMIndexSeqT = Seq (Maybe Text)

-- | Simple Inverse FMIndex function.
seqFromFMIndexT :: FMIndexT
                -> FFMIndexSeqT
seqFromFMIndexT :: FMIndexT -> Seq (Maybe Text)
seqFromFMIndexT (FMIndexT (CcT Seq (Int, Maybe Text)
DS.Empty,OccCKT
_))    = forall a. Seq a
DS.Empty
seqFromFMIndexT (FMIndexT (CcT
_,OccCKT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
DS.Empty)) = forall a. Seq a
DS.Empty
seqFromFMIndexT FMIndexT
xs                             = do
  let xss :: Seq (Maybe Text, Seq (Int, Int, Maybe Text))
xss = (\(OccCKT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
t) -> Seq (Maybe Text, Seq (Int, Int, Maybe Text))
t) forall a b. (a -> b) -> a -> b
$
            (\(CcT
_,OccCKT
b) -> OccCKT
b)      forall a b. (a -> b) -> a -> b
$
            (\(FMIndexT (CcT, OccCKT)
t) -> (CcT, OccCKT)
t) FMIndexT
xs
  forall {a} {a} {b} {a}. Seq (a, Seq (a, b, a)) -> Seq a
iFFMIndexT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
xss
    where
      iFFMIndexT :: Seq (a, Seq (a, b, a)) -> Seq a
iFFMIndexT Seq (a, Seq (a, b, a))
DS.Empty         = forall a. Seq a
DS.Empty
      iFFMIndexT ((a
_,Seq (a, b, a)
b) DS.:<| Seq (a, Seq (a, b, a))
_) =
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(a
_,b
_,a
e) -> a
e) Seq (a, b, a)
b

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