-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A text compression library.
--   
--   This package contains efficient implementations of various text
--   compression algorithms.
@package text-compression
@version 0.1.0.13


-- | <h1>WARNING</h1>
--   
--   This module is considered <b>internal</b>.
--   
--   The Package Versioning Policy <b>does not apply</b>.
--   
--   The contents of this module may change <b>in any way whatsoever</b>
--   and <b>without any warning</b> 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
--   <a>containers</a> library for the above warning text.
--   
--   <h1>Description</h1>
--   
--   Various data structures and custom data types to describe the
--   Burrows-Wheeler Transform (BWT) and the Inverse BWT.
--   
--   The implementation of the BWT relies upon <a>Seq</a> provided by the
--   <a>containers</a>.
--   
--   The internal <a>BWTMatrix</a> data type relies upon the <a>Seq</a> as
--   well.
module Data.BWT.Internal

-- | Basic suffix data type. Used to describe the core data inside of the
--   <a>SuffixArray</a> data type.
data Suffix a
Suffix :: Int -> Int -> Maybe (Seq a) -> Suffix a
[suffixindex] :: Suffix a -> Int
[suffixstartpos] :: Suffix a -> Int
[suffix] :: Suffix a -> Maybe (Seq a)

-- | The SuffixArray data type. Uses <a>Seq</a> internally.
type SuffixArray a = Seq (Suffix a)

-- | The BWT data type. Uses <a>Seq</a> internally.
newtype BWT a
BWT :: Seq (Maybe a) -> BWT a

-- | The BWTMatrix data type. Uses a <a>Array</a> internally.
newtype BWTMatrix a
BWTMatrix :: Seq (Seq (Maybe a)) -> BWTMatrix a

-- | Computes the Burrows-Wheeler Transform (BWT) using the suffix array
--   and the original string (represented as a <a>Seq</a> for performance).
saToBWT :: SuffixArray a -> Seq a -> Seq (Maybe a)

-- | Computes the corresponding <a>SuffixArray</a> of a given string.
--   Please see <a>suffix array</a> for more information.
createSuffixArray :: Ord a => Seq a -> SuffixArray a

-- | Hierarchical sorting scheme that compares fst first then snd.
--   Necessary for the setting up the BWT in order to correctly invert it
--   using the <a>Magic</a> algorithm.
sortTB :: (Ord a1, Ord a2) => (a1, a2) -> (a1, a2) -> Ordering

-- | Abstract BWTSeq type utilizing a <a>Seq</a>.
type BWTSeq a = Seq a

-- | Abstract data type representing a BWTSeq in the (strict) ST monad.
type STBWTSeq s a = STRef s (BWTSeq a)

-- | State function to push BWTString data into stack.
pushSTBWTSeq :: STBWTSeq s a -> a -> ST s ()

-- | State function to create empty STBWTString type.
emptySTBWTSeq :: ST s (STBWTSeq s a)

-- | Abstract BWTCounter and associated state type.
type STBWTCounter s a = STRef s Int

-- | State function to update BWTCounter.
updateSTBWTCounter :: STBWTCounter s Int -> Int -> ST s ()

-- | State function to create empty STBWTCounter type.
emptySTBWTCounter :: ST s (STBWTCounter s Int)

-- | <a>Magic</a> Inverse BWT function.
magicInverseBWT :: Seq (Maybe a, Int) -> ST s (BWTSeq a)

-- | Simple yet efficient implementation of converting a given string into
--   a BWT Matrix (the BWTMatrix type is a <a>Seq</a> (<a>Maybe</a> a).
createBWTMatrix :: Ord a => [a] -> BWTMatrix a
instance GHC.Generics.Generic (Data.BWT.Internal.Suffix a)
instance GHC.Read.Read a => GHC.Read.Read (Data.BWT.Internal.Suffix a)
instance GHC.Show.Show a => GHC.Show.Show (Data.BWT.Internal.Suffix a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.BWT.Internal.Suffix a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.BWT.Internal.Suffix a)
instance GHC.Generics.Generic (Data.BWT.Internal.BWT a)
instance GHC.Read.Read a => GHC.Read.Read (Data.BWT.Internal.BWT a)
instance GHC.Show.Show a => GHC.Show.Show (Data.BWT.Internal.BWT a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.BWT.Internal.BWT a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.BWT.Internal.BWT a)
instance GHC.Generics.Generic (Data.BWT.Internal.BWTMatrix a)
instance GHC.Read.Read a => GHC.Read.Read (Data.BWT.Internal.BWTMatrix a)
instance GHC.Show.Show a => GHC.Show.Show (Data.BWT.Internal.BWTMatrix a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.BWT.Internal.BWTMatrix a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.BWT.Internal.BWTMatrix a)


-- | <h1>Burrows-Wheeler Transform (BWT)</h1>
--   
--   The two functions that most users will utilize are <a>toBWT</a> and
--   <a>fromBWT</a>. There are auxilary function(s) inside of
--   <tt><a>Data.BWT.Internal</a></tt>.
--   
--   The helper functions for ByteString, <a>bytestringToBWT</a>,
--   <a>bytestringFromWord8BWT</a>, <a>bytestringFromByteStringBWT</a> and
--   Text, <a>textToBWT</a> and <a>textFromBWT</a> should help for common
--   use cases.
--   
--   <tt><a>Data.BWT.Internal</a></tt> also has the function
--   <a>createBWTMatrix</a>, which can be useful as well, although not used
--   by either <a>toBWT</a> or <a>fromBWT</a>.
module Data.BWT

-- | Takes a String and returns the Burrows-Wheeler Transform (BWT).
--   Implemented via a <a>SuffixArray</a>.
toBWT :: Ord a => [a] -> BWT a

-- | Helper function for converting a <a>ByteString</a> to a <a>BWT</a>
--   <a>Word8</a>.
bytestringToBWT :: ByteString -> BWT Word8

-- | A newtype to ensure you only uncompress a <a>BWT</a> created from
--   <a>textToBWT</a>, since [<a>Word8</a>] -&gt; <a>Text</a> is partial.
newtype TextBWT
TextBWT :: BWT Word8 -> TextBWT

-- | Helper function for converting <a>Text</a> to a <a>TextBWT</a>.
textToBWT :: Text -> TextBWT

-- | Takes a BWT data type (please see <tt><a>Data.BWT.Internal</a></tt>)
--   and inverts it back to the original string.
--   
--   This function utilizes the state monad (strict) in order to implement
--   the <a>Magic</a> Inverse BWT algorithm by backtracking indices
--   starting with the (<b>Nothing</b>,_) entry.
fromBWT :: Ord a => BWT a -> [a]

-- | Helper function for converting a <a>BWT</a> of <a>Word8</a>s to a
--   <a>ByteString</a>.
bytestringFromWord8BWT :: BWT Word8 -> ByteString

-- | Helper function for converting a <a>BWT</a> <a>ByteString</a>s to a
--   <a>ByteString</a>.
bytestringFromByteStringBWT :: BWT ByteString -> ByteString

-- | Helper function for converting <a>TextBWT</a> to a <a>Text</a>
textFromBWT :: TextBWT -> Text
instance GHC.Generics.Generic Data.BWT.TextBWT
instance GHC.Read.Read Data.BWT.TextBWT
instance GHC.Show.Show Data.BWT.TextBWT
instance GHC.Classes.Ord Data.BWT.TextBWT
instance GHC.Classes.Eq Data.BWT.TextBWT


-- | <h1>WARNING</h1>
--   
--   This module is considered <b>internal</b>.
--   
--   The Package Versioning Policy <b>does not apply</b>.
--   
--   The contents of this module may change <b>in any way whatsoever</b>
--   and <b>without any warning</b> 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
--   <a>containers</a> library for the above warning text.
--   
--   <h1>Description</h1>
--   
--   Various data structures and custom data types to describe the
--   Move-to-front transform (MTF) and the Inverse MTF implementations,
--   namely <a>seqToMTFB</a>, <a>seqToMTFT</a>, <a>seqFromMTFB</a>, and
--   <a>seqFromMTFT</a>.
--   
--   The MTF implementations rely heavily upon <a>Seq</a> provided by the
--   <a>containers</a>, <a>STRef</a> and associated functions in the
--   <a>stref</a> library, and <a>runST</a> in the <a>Control.Monad.ST</a>
--   library.
module Data.MTF.Internal

-- | Basic MTF (<a>ByteString</a>) data type.
newtype MTFB
MTFB :: (Seq Int, Seq (Maybe ByteString)) -> MTFB

-- | Basic MTF (<a>Text</a>) data type.
newtype MTFT
MTFT :: (Seq Int, Seq (Maybe Text)) -> MTFT

-- | Useful to acquire the unique elements that make up a <a>Seq</a>.
--   Credit to @DavidFletcher. See <a>this stackoverflow post</a>.
nubSeq' :: Ord a => Seq (Maybe a) -> Seq (Maybe a)

-- | Abstract <a>PBMTFSeqB</a> type utilizing a <a>Seq</a>
type PBMTFSeqB = Seq (Maybe ByteString)

-- | Abstract <a>MTFLSSeqB</a> type utilizing a <a>Seq</a>.
type MTFLSSeqB = (Seq Int, Seq (Maybe ByteString))

-- | Abstract data type representing a <a>MTFLSSeqB</a> in the (strict) ST
--   monad.
type STMTFLSSeqB s a = STRef s MTFLSSeqB

-- | Abstract data type to initialize a <a>STMTFLSSeqB</a> using the
--   initial list.
initializeSTMTFLSSeqB :: STMTFLSSeqB s (Seq Int, Seq (Maybe ByteString)) -> Seq (Maybe ByteString) -> ST s ()

-- | State function to update <a>MTFLSSeqB</a> with each step of the MTF.
updateSTMTFLSSeqB :: STMTFLSSeqB s (Seq Int, Seq (Maybe ByteString)) -> Int -> ST s ()

-- | State function to create empty <a>STMTFLSSeqB</a> type.
emptySTMTFLSSeqB :: ST s (STMTFLSSeqB s a)

-- | Abstract <a>STMTFILB</a> and associated state type.
type STMTFILB s a = STRef s (Seq (Maybe ByteString))

-- | State function to load list into <a>STMTFILB</a>.
loadSTMTFILB :: STMTFILB s (Maybe ByteString) -> Seq (Maybe ByteString) -> ST s ()

-- | State function to create empty <a>STMTFILB</a> type.
emptySTMTFILB :: ST s (STMTFILB s a)

-- | Abstract <a>STMTFCounterB</a> and associated state type.
type STMTFCounterB s a = STRef s Int

-- | State function to update <a>STMTFCounterB</a>.
updateSTMTFCounterB :: STMTFCounterB s Int -> Int -> ST s ()

-- | State function to create empty <a>STMTFCounterB</a> type.
emptySTMTFCounterB :: ST s (STMTFCounterB s Int)

-- | Strict state monad function.
seqToMTFB :: PBMTFSeqB -> ST s MTFLSSeqB

-- | Abstract <a>PTMTFSeqT</a> type utilizing a <a>Seq</a>
type PTMTFSeqT = Seq (Maybe Text)

-- | Abstract <a>MTFLSSeqT</a> type utilizing a <a>Seq</a>.
type MTFLSSeqT = (Seq Int, Seq (Maybe Text))

-- | Abstract data type representing a <a>MTFLSSeqT</a> in the (strict) ST
--   monad.
type STMTFLSSeqT s a = STRef s MTFLSSeqT

-- | Abstract data type to initialize a <a>STMTFLSSeqT</a> using the
--   initial list.
initializeSTMTFLSSeqT :: STMTFLSSeqT s (Seq Int, Seq (Maybe Text)) -> Seq (Maybe Text) -> ST s ()

-- | State function to update <a>STMTFLSSeqT</a> with each step of the MTF.
updateSTMTFLSSeqT :: STMTFLSSeqT s (Seq Int, Seq (Maybe Text)) -> Int -> ST s ()

-- | State function to create empty <a>STMTFLSSeqT</a> type.
emptySTMTFLSSeqT :: ST s (STMTFLSSeqT s a)

-- | Abstract <a>STMTFILT</a> and associated state type.
type STMTFILT s a = STRef s (Seq (Maybe Text))

-- | State function to load list into <a>STMTFILT</a>.
loadSTMTFILT :: STMTFILT s (Maybe Text) -> Seq (Maybe Text) -> ST s ()

-- | State function to create empty <a>STMTFILT</a> type.
emptySTMTFILT :: ST s (STMTFILT s a)

-- | Abstract <a>STMTFCounterT</a> and associated state type.
type STMTFCounterT s a = STRef s Int

-- | State function to update <a>STMTFCounterT</a>.
updateSTMTFCounterT :: STMTFCounterT s Int -> Int -> ST s ()

-- | State function to create empty <a>STMTFCounterT</a> type.
emptySTMTFCounterT :: ST s (STMTFCounterT s Int)

-- | Strict state monad function.
seqToMTFT :: PTMTFSeqT -> ST s MTFLSSeqT

-- | Abstract <a>FMTFSeqB</a> type utilizing a <a>Seq</a>.
type FMTFSeqB = Seq (Maybe ByteString)

-- | Abstract data type representing a <a>FMTFSeqB</a> in the (strict) ST
--   monad.
type FSTMTFSeqB s a = STRef s FMTFSeqB

-- | State function to update <a>FSTMTFSeqB</a> with each step of the
--   inverse MTF.
updateFSTMTFSeqB :: FSTMTFSeqB s (Maybe ByteString) -> Maybe ByteString -> ST s ()

-- | State function to create empty <a>FSTMTFSeqB</a> type.
emptyFSTMTFSeqB :: ST s (FSTMTFSeqB s a)

-- | Abstract <a>FSTMTFILB</a> and associated state type.
type FSTMTFILB s a = STRef s (Seq (Maybe ByteString))

-- | State function to load list into <a>FSTMTFILB</a>.
loadFSTMTFILB :: FSTMTFILB s (Maybe ByteString) -> Seq (Maybe ByteString) -> ST s ()

-- | State function to update <a>FSTMTFILB</a>.
updateFSTMTFILB :: FSTMTFILB s (Maybe ByteString) -> Int -> ST s ()

-- | State function to create empty <a>FSTMTFILB</a> type.
emptyFSTMTFILB :: ST s (FSTMTFILB s a)

-- | Strict state monad function.
seqFromMTFB :: MTFB -> ST s FMTFSeqB

-- | Abstract <a>FMTFSeqT</a> type utilizing a <a>Seq</a>.
type FMTFSeqT = Seq (Maybe Text)

-- | Abstract data type representing a <a>FMTFSeqT</a> in the (strict) ST
--   monad.
type FSTMTFSeqT s a = STRef s FMTFSeqT

-- | State function to update <a>FSTMTFSeqT</a> with each step of the
--   inverse MTF.
updateFSTMTFSeqT :: FSTMTFSeqT s (Maybe Text) -> Maybe Text -> ST s ()

-- | State function to create empty <a>FSTMTFSeqT</a> type.
emptyFSTMTFSeqT :: ST s (FSTMTFSeqT s a)

-- | Abstract <a>FSTMTFILT</a> and associated state type.
type FSTMTFILT s a = STRef s (Seq (Maybe Text))

-- | State function to load list into <a>FSTMTFILT</a>.
loadFSTMTFILT :: FSTMTFILT s (Maybe Text) -> Seq (Maybe Text) -> ST s ()

-- | State function to update <a>FSTMTFILT</a>.
updateFSTMTFILT :: FSTMTFILT s (Maybe Text) -> Int -> ST s ()

-- | State function to create empty <a>FSTMTFILT</a> type.
emptyFSTMTFILT :: ST s (FSTMTFILT s a)

-- | Strict state monad function.
seqFromMTFT :: MTFT -> ST s FMTFSeqT
instance GHC.Generics.Generic Data.MTF.Internal.MTFB
instance GHC.Read.Read Data.MTF.Internal.MTFB
instance GHC.Show.Show Data.MTF.Internal.MTFB
instance GHC.Classes.Ord Data.MTF.Internal.MTFB
instance GHC.Classes.Eq Data.MTF.Internal.MTFB
instance GHC.Generics.Generic Data.MTF.Internal.MTFT
instance GHC.Read.Read Data.MTF.Internal.MTFT
instance GHC.Show.Show Data.MTF.Internal.MTFT
instance GHC.Classes.Ord Data.MTF.Internal.MTFT
instance GHC.Classes.Eq Data.MTF.Internal.MTFT


-- | <h1>Move-to-front transform (MTF)</h1>
--   
--   Users will get the most mileage by first compressing to a <a>BWT</a>
--   on the initial <a>ByteString</a> or <a>Text</a> input before
--   compressing to a <a>MTFB</a> or <a>MTFT</a>.
--   
--   To do this, users can use the <a>bytestringToBWTToMTFB</a> and
--   <a>bytestringToBWTToMTFT</a> functions, as well as the
--   <a>textToBWTToMTFB</a> and <a>textToBWTToMTFT</a> functions.
--   
--   The base functions for <a>ByteString</a>, <a>bytestringToMTFB</a> and
--   <a>bytestringToMTFT</a> can be used to convert a <a>Seq</a>
--   (<a>Maybe</a> <a>ByteString</a>) to a <a>MTFB</a> and <a>MTFT</a>,
--   respectively.
--   
--   Likewise, the base functions for <a>Text</a>, <a>textToMTFB</a> and
--   <a>textToMTFT</a> can be used to convert a <a>Seq</a> (<a>Maybe</a>
--   <a>Text</a>) to a <a>MTFB</a> and <a>MTFT</a> respectively.
--   
--   There are various other lower-level functions for interacting with the
--   MTF implementation on <a>ByteString</a> and <a>Text</a> as well.
--   
--   <tt><a>Data.MTF.Internal</a></tt> contains efficient and stateful
--   implementations of the MTF and Inverse MTF algorithms.
module Data.MTF

-- | Helper function for converting a <a>ByteString</a> to a <a>MTFB</a>
--   via a <a>BWT</a> first.
bytestringToBWTToMTFB :: ByteString -> MTFB

-- | Helper function for converting a <a>ByteString</a> to a <a>MTFT</a>
--   via a <a>BWT</a> first.
bytestringToBWTToMTFT :: ByteString -> MTFT

-- | Helper function for converting a <a>Text</a> to a <a>MTFB</a> via a
--   <a>BWT</a> first.
textToBWTToMTFB :: Text -> MTFB

-- | Helper function for converting a <a>Text</a> to a <a>MTFT</a> via a
--   <a>BWT</a> first.
textToBWTToMTFT :: Text -> MTFT

-- | Take a <a>BWT</a> of <a>Word8</a>s and generate the Move-to-front
--   transform (<a>MTFB</a>).
textBWTToMTFB :: TextBWT -> MTFB

-- | Take a <a>BWT</a> of <a>Word8</a>s and generate the Move-to-front
--   transform (<a>MTFB</a>).
bytestringBWTToMTFB :: BWT Word8 -> MTFB

-- | Take a <a>BWT</a> of <a>Word8</a>s and generate the Move-to-front
--   transform (<a>MTFB</a>).
textBWTToMTFT :: TextBWT -> MTFT

-- | Take a <a>BWT</a> of <a>Word8</a>s and generate the Move-to-front
--   transform (<a>MTFT</a>).
bytestringBWTToMTFT :: BWT Word8 -> MTFT

-- | Takes a <a>Text</a> and returns the Move-to-front transform
--   (<a>MTFB</a>).
textToMTFB :: Seq (Maybe Text) -> MTFB

-- | Takes a <a>Seq</a> of <a>ByteString</a>s and returns the Move-to-front
--   transform (<a>MTFB</a>).
bytestringToMTFB :: Seq (Maybe ByteString) -> MTFB

-- | Takes a <a>Text</a> and returns the Move-to-front transform
--   (<a>MTFT</a>).
textToMTFT :: Seq (Maybe Text) -> MTFT

-- | Takes a <a>ByteString</a> and returns the Move-to-front transform
--   (<a>MTFT</a>).
bytestringToMTFT :: Seq (Maybe ByteString) -> MTFT

-- | Helper function for converting a <a>BWT</a>ed <a>MTFB</a> back to the
--   original <a>ByteString</a>.
bytestringFromBWTFromMTFB :: MTFB -> ByteString

-- | Helper function for converting a <a>BWT</a>ed <a>MTFT</a> back to the
--   original <a>ByteString</a>.
bytestringFromBWTFromMTFT :: MTFT -> ByteString

-- | Helper function for converting a <a>BWT</a>ed <a>MTFB</a> back to the
--   original <a>Text</a>.
textFromBWTFromMTFB :: MTFB -> Text

-- | Helper function for converting a <a>BWT</a>ed <a>MTFT</a> back to the
--   original <a>Text</a>.
textFromBWTFromMTFT :: MTFT -> Text

-- | Takes a <a>MTFT</a> and returns the <a>BWT</a> of <a>Text</a>s.
textBWTFromMTFT :: MTFT -> BWT Text

-- | Takes a <a>MTFT</a> and returns the <a>BWT</a> of <a>ByteString</a>s.
bytestringBWTFromMTFT :: MTFT -> BWT ByteString

-- | Takes a <a>MTFB</a> and returns the <a>BWT</a> of <a>Text</a>s.
textBWTFromMTFB :: MTFB -> BWT Text

-- | Take a <a>MTFB</a> and returns the <a>BWT</a> of <a>ByteString</a>s.
bytestringBWTFromMTFB :: MTFB -> BWT ByteString

-- | Takes a <a>MTFB</a> and returns the original <a>Seq</a> of
--   <a>Text</a>s.
textFromMTFB :: MTFB -> Seq (Maybe Text)

-- | Takes a <a>MTFB</a> and returns the original <a>Seq</a> of
--   <a>ByteString</a>s.
bytestringFromMTFB :: MTFB -> Seq (Maybe ByteString)

-- | Takes a <a>MTFT</a> and returns the original <a>Seq</a> of
--   <a>Text</a>s.
textFromMTFT :: MTFT -> Seq (Maybe Text)

-- | Takes a <a>MTFT</a> and returns the original <a>Seq</a> of
--   <a>ByteString</a>s.
bytestringFromMTFT :: MTFT -> Seq (Maybe ByteString)


-- | <h1>WARNING</h1>
--   
--   This module is considered <b>internal</b>.
--   
--   The Package Versioning Policy <b>does not apply</b>.
--   
--   The contents of this module may change <b>in any way whatsoever</b>
--   and <b>without any warning</b> 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
--   <a>containers</a> library for the above warning text.
--   
--   <h1>Description</h1>
--   
--   Various data structures and custom data types to describe the
--   <a>Full-text Minute-space index (FM-index)</a> and the Inverse
--   FM-index implementations, namely <a>seqToFMIndexB</a>,
--   <a>seqToFMIndexT</a>, <a>seqFromFMIndexB</a>, and
--   <a>seqFromFMIndexT</a>.
--   
--   The FM-index implementations rely heavily upon <a>Seq</a> provided by
--   the <a>containers</a>, <a>STRef</a> and associated functions in the
--   <a>stref</a> library, and <a>runST</a> in the <a>Control.Monad.ST</a>
--   library.
module Data.FMIndex.Internal

-- | Basic FMIndex (<a>ByteString</a>) data type.
newtype FMIndexB
FMIndexB :: Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)) -> FMIndexB

-- | Basic FMIndex (<a>Text</a>) data type.
newtype FMIndexT
FMIndexT :: Seq (Maybe Text, Seq (Int, Int, Maybe Text)) -> FMIndexT

-- | Abstract <a>PBFMIndexSeqB</a> type utilizing a <a>Seq</a>.
type PBFMIndexSeqB = Seq (Maybe ByteString)

-- | Abstract <a>FMIndexSeqB</a> type utilizing a <a>Seq</a>.
--   (c,(indexofinputcurrentelement,Occ(c,k),inputcurrentelement)) Please
--   see <a>this</a> for an explanation of the above abbreviations.
type FMIndexSeqB = Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))

-- | Abstract data type representing a <a>FMIndexSeqB</a> in the (strict)
--   ST monad.
type STFMIndexSeqB s a = STRef s FMIndexSeqB

-- | State function to update <a>FMIndexSeqB</a> with each step of the
--   FMIndex.
updateSTFMIndexSeqAB :: STFMIndexSeqB s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))) -> (Int, Int, Maybe ByteString) -> ST s ()

-- | State function to update <a>FMIndexSeqB</a> with each step of the
--   FMIndex.
updateSTFMIndexSeqBB :: STFMIndexSeqB s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))) -> Maybe ByteString -> ST s ()

-- | State function to create empty <a>STFMIndexSeqB</a> type.
emptySTFMIndexSeqB :: ST s (STFMIndexSeqB s a)

-- | Abstract <a>STFMIndexILB</a> and associated state type.
type STFMIndexILB s a = STRef s (Seq (Maybe ByteString))

-- | State function to load list into <a>STFMIndexILB</a>.
loadSTFMIndexILB :: STMTFILB s (Maybe ByteString) -> Seq (Maybe ByteString) -> ST s ()

-- | State function to create empty <a>STFMIndexILB</a> type.
emptySTFMIndexILB :: ST s (STFMIndexILB s a)

-- | Abstract <a>STFMIndexCounterB</a> and associated state type.
type STFMIndexCounterB s a = STRef s Int

-- | State function to update <a>STFMIndexCounterB</a>.
updateSTFMIndexCounterB :: STFMIndexCounterB s Int -> Int -> ST s ()

-- | State function to create empty <a>STFMIndexCounterB</a> type.
emptySTFMIndexCounterB :: ST s (STFMIndexCounterB s Int)

-- | Strict state monad function.
seqToFMIndexB :: PBFMIndexSeqB -> ST s FMIndexSeqB

-- | Abstract <a>PTFMIndexSeqT</a> type utilizing a <a>Seq</a>.
type PTFMIndexSeqT = Seq (Maybe Text)

-- | Abstract <a>FMIndexSeqT</a> type utilizing a <a>Seq</a>.
--   (c,(indexofinputcurrentelement,Occ(c,k),inputcurrentelement)) Please
--   see <a>this</a> for an explanation of the above abbreviations.
type FMIndexSeqT = Seq (Maybe Text, Seq (Int, Int, Maybe Text))

-- | Abstract data type representing a <a>FMIndexSeqT</a> in the (strict)
--   ST monad.
type STFMIndexSeqT s a = STRef s FMIndexSeqT

-- | State function to update <a>FMIndexSeqT</a> with each step of the
--   FMIndex.
updateSTFMIndexSeqAT :: STFMIndexSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text))) -> (Int, Int, Maybe Text) -> ST s ()

-- | State function to update <a>FMIndexSeqT</a> with each step of the
--   FMIndex.
updateSTFMIndexSeqBT :: STFMIndexSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text))) -> Maybe Text -> ST s ()

-- | State function to create empty <a>STFMIndexSeqT</a> type.
emptySTFMIndexSeqT :: ST s (STFMIndexSeqT s a)

-- | Abstract <a>STFMIndexILT</a> and associated state type.
type STFMIndexILT s a = STRef s (Seq (Maybe Text))

-- | State function to load list into <a>STFMIndexILT</a>.
loadSTFMIndexILT :: STMTFILT s (Maybe Text) -> Seq (Maybe Text) -> ST s ()

-- | State function to create empty <a>STFMIndexILT</a> type.
emptySTFMIndexILT :: ST s (STFMIndexILT s a)

-- | Abstract <a>STFMIndexCounterT</a> and associated state type.
type STFMIndexCounterT s a = STRef s Int

-- | State function to update <a>STFMIndexCounterT</a>.
updateSTFMIndexCounterT :: STFMIndexCounterT s Int -> Int -> ST s ()

-- | State function to create empty <a>STFMIndexCounterT</a> type.
emptySTFMIndexCounterT :: ST s (STFMIndexCounterT s Int)

-- | Strict state monad function.
seqToFMIndexT :: PTFMIndexSeqT -> ST s FMIndexSeqT

-- | Abstract <a>FFMIndexSeqB</a> type utilizing a <a>Seq</a>.
type FFMIndexSeqB = Seq (Maybe ByteString)

-- | Simple Inverse FMIndex function.
seqFromFMIndexB :: FMIndexB -> FFMIndexSeqB

-- | Abstract <a>FFMIndexSeqT</a> type utilizing a <a>Seq</a>.
type FFMIndexSeqT = Seq (Maybe Text)

-- | Simple Inverse FMIndex function.
seqFromFMIndexT :: FMIndexT -> FFMIndexSeqT
instance GHC.Generics.Generic Data.FMIndex.Internal.FMIndexB
instance GHC.Read.Read Data.FMIndex.Internal.FMIndexB
instance GHC.Show.Show Data.FMIndex.Internal.FMIndexB
instance GHC.Classes.Ord Data.FMIndex.Internal.FMIndexB
instance GHC.Classes.Eq Data.FMIndex.Internal.FMIndexB
instance GHC.Generics.Generic Data.FMIndex.Internal.FMIndexT
instance GHC.Read.Read Data.FMIndex.Internal.FMIndexT
instance GHC.Show.Show Data.FMIndex.Internal.FMIndexT
instance GHC.Classes.Ord Data.FMIndex.Internal.FMIndexT
instance GHC.Classes.Eq Data.FMIndex.Internal.FMIndexT


-- | <h1>Full-text Minute-space index (FM-index)</h1>
--   
--   Users will get the most mileage by first compressing to a <a>BWT</a>
--   on the initial <a>ByteString</a> or <a>Text</a> input before
--   compressing to a <a>FMIndexB</a> or <a>FMIndexT</a>.
--   
--   To do this, users can use the <a>bytestringToBWTToFMIndexB</a> and
--   <a>bytestringToBWTToFMIndexT</a> functions, as well as the
--   <a>textToBWTToFMIndexB</a> and <a>textToBWTToFMIndexT</a> functions.
--   
--   The base functions for <a>ByteString</a>, <a>bytestringToFMIndexB</a>
--   and <a>bytestringToFMIndexT</a> can be used to convert a <a>Seq</a>
--   (<a>Maybe</a> <a>ByteString</a>) to a <a>FMIndexB</a> and
--   <a>FMIndexT</a>, respectively.
--   
--   Likewise, the base functions for <a>Text</a>, <a>textToFMIndexB</a>
--   and <a>textToFMIndexT</a> can be used to convert a <a>Seq</a>
--   (<a>Maybe</a> <a>Text</a>) to a <a>FMIndexB</a> and <a>FMIndexT</a>
--   respectively.
--   
--   There are various other lower-level functions for interacting with the
--   FMIndex implementation on <a>ByteString</a> and <a>Text</a> as well.
--   
--   <tt><a>Data.FMIndex.Internal</a></tt> contains efficient and stateful
--   implementations of the FMIndex and Inverse FMIndex algorithms.
module Data.FMIndex

-- | Helper function for converting a <a>ByteString</a> to a
--   <a>FMIndexB</a> via a <a>BWT</a> first.
bytestringToBWTToFMIndexB :: ByteString -> FMIndexB

-- | Helper function for converting a <a>ByteString</a> to a
--   <a>FMIndexT</a> via a <a>BWT</a> first.
bytestringToBWTToFMIndexT :: ByteString -> FMIndexT

-- | Helper function for converting a <a>Text</a> to a <a>FMIndexB</a> via
--   a <a>BWT</a> first.
textToBWTToFMIndexB :: Text -> FMIndexB

-- | Helper function for converting a <a>Text</a> to a <a>FMIndexT</a> via
--   a <a>BWT</a> first.
textToBWTToFMIndexT :: Text -> FMIndexT

-- | Take a <a>BWT</a> of <a>Word8</a>s and generate the FM-index
--   (<a>FMIndexB</a>).
textBWTToFMIndexB :: TextBWT -> FMIndexB

-- | Take a <a>BWT</a> of <a>Word8</a>s and generate the FM-index
--   (<a>FMIndexB</a>).
bytestringBWTToFMIndexB :: BWT Word8 -> FMIndexB

-- | Take a <a>BWT</a> of <a>Word8</a>s and generate the FM-index
--   (<a>FMIndexB</a>).
textBWTToFMIndexT :: TextBWT -> FMIndexT

-- | Take a <a>BWT</a> of <a>Word8</a>s and generate the FM-index
--   (<a>FMIndexT</a>).
bytestringBWTToFMIndexT :: BWT Word8 -> FMIndexT

-- | Takes a <a>Text</a> and returns the FM-index (<a>FMIndexB</a>).
textToFMIndexB :: Seq (Maybe Text) -> FMIndexB

-- | Takes a <a>Seq</a> of <a>ByteString</a>s and returns the FM-index
--   (<a>FMIndexB</a>).
bytestringToFMIndexB :: Seq (Maybe ByteString) -> FMIndexB

-- | Takes a <a>Text</a> and returns the FM-index (<a>FMIndexT</a>).
textToFMIndexT :: Seq (Maybe Text) -> FMIndexT

-- | Takes a <a>ByteString</a> and returns the FM-index (<a>FMIndexT</a>).
bytestringToFMIndexT :: Seq (Maybe ByteString) -> FMIndexT

-- | Helper function for converting a <a>BWT</a>ed <a>FMIndexB</a> back to
--   the original <a>ByteString</a>.
bytestringFromBWTFromFMIndexB :: FMIndexB -> ByteString

-- | Helper function for converting a <a>BWT</a>ed <a>FMIndexT</a> back to
--   the original <a>ByteString</a>.
bytestringFromBWTFromFMIndexT :: FMIndexT -> ByteString

-- | Helper function for converting a <a>BWT</a>ed <a>FMIndexB</a> back to
--   the original <a>Text</a>.
textFromBWTFromFMIndexB :: FMIndexB -> Text

-- | Helper function for converting a <a>BWT</a>ed <a>FMIndexT</a> back to
--   the original <a>Text</a>.
textFromBWTFromFMIndexT :: FMIndexT -> Text

-- | Takes a <a>FMIndexT</a> and returns the <a>BWT</a> of <a>Text</a>s.
textBWTFromFMIndexT :: FMIndexT -> BWT Text

-- | Takes a <a>FMIndexT</a> and returns the <a>BWT</a> of
--   <a>ByteString</a>s.
bytestringBWTFromFMIndexT :: FMIndexT -> BWT ByteString

-- | Takes a <a>FMIndexB</a> and returns the <a>BWT</a> of <a>Text</a>s.
textBWTFromFMIndexB :: FMIndexB -> BWT Text

-- | Take a <a>FMIndexB</a> and returns the <a>BWT</a> of
--   <a>ByteString</a>s.
bytestringBWTFromFMIndexB :: FMIndexB -> BWT ByteString

-- | Takes a <a>FMIndexB</a> and returns the original <a>Seq</a> of
--   <a>Text</a>s.
textFromFMIndexB :: FMIndexB -> Seq (Maybe Text)

-- | Takes a <a>FMIndexB</a> and returns the original <a>Seq</a> of
--   <a>ByteString</a>s.
bytestringFromFMIndexB :: FMIndexB -> Seq (Maybe ByteString)

-- | Takes a <a>FMIndexT</a> and returns the original <a>Seq</a> of
--   <a>Text</a>s.
textFromFMIndexT :: FMIndexT -> Seq (Maybe Text)

-- | Takes a <a>FMIndexT</a> and returns the original <a>Seq</a> of
--   <a>ByteString</a>s.
bytestringFromFMIndexT :: FMIndexT -> Seq (Maybe ByteString)


-- | <h1>WARNING</h1>
--   
--   This module is considered <b>internal</b>.
--   
--   The Package Versioning Policy <b>does not apply</b>.
--   
--   The contents of this module may change <b>in any way whatsoever</b>
--   and <b>without any warning</b> 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
--   <a>containers</a> library for the above warning text.
--   
--   <h1>Description</h1>
--   
--   Various data structures and custom data types to describe the
--   Run-length encoding (RLE) and the Inverse RLE implementations, namely
--   <a>seqToRLEB</a>, <a>seqToRLET</a>, <a>seqFromRLEB</a>, and
--   <a>seqFromRLET</a>.
--   
--   The RLE implementations rely heavily upon <a>Seq</a> provided by the
--   <a>containers</a>, <a>STRef</a> and associated functions in the
--   <a>stref</a> library, and <a>runST</a> in the <a>Control.Monad.ST</a>
--   library.
module Data.RLE.Internal

-- | Basic RLE (<a>ByteString</a>) data type.
newtype RLEB
RLEB :: Seq (Maybe ByteString) -> RLEB

-- | Basic RLE (<a>Text</a>) data type.
newtype RLET
RLET :: Seq (Maybe Text) -> RLET

-- | Abstract <a>RLESeqB</a> type utilizing a <a>Seq</a>.
type RLESeqB = Seq (Maybe ByteString)

-- | Abstract data type representing a <a>RLESeqB</a> in the (strict) ST
--   monad.
type STRLESeqB s a = STRef s RLESeqB

-- | State function to push <a>RLESeqB</a> data into stack.
pushSTRLESeqB :: STRLESeqB s (Maybe ByteString) -> Maybe ByteString -> ST s ()

-- | State function to create empty <a>STRLESeqB</a> type.
emptySTRLESeqB :: ST s (STRLESeqB s a)

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

-- | State function to update <a>STRLETempB</a>.
updateSTRLETempB :: STRLETempB s (Maybe ByteString) -> Maybe ByteString -> ST s ()

-- | State function to create empty <a>STRLETempB</a> type.
emptySTRLETempB :: ST s (STRLETempB s a)

-- | Abstract <a>STRLECounterB</a> state type.
type STRLECounterB s a = STRef s Int

-- | State function to update <a>STRLECounterB</a>.
updateSTRLECounterB :: STRLECounterB s Int -> Int -> ST s ()

-- | State function to create empty <a>STRLECounterB</a> type.
emptySTRLECounterB :: ST s (STRLECounterB s Int)

-- | Strict state monad function.
seqToRLEB :: RLESeqB -> ST s RLESeqB

-- | Abstract <a>RLESeqT</a> type utilizing a <a>Seq</a>.
type RLESeqT = Seq (Maybe Text)

-- | Abstract data type representing a <a>RLESeqT</a> in the (strict) ST
--   monad.
type STRLESeqT s a = STRef s RLESeqT

-- | State function to push <a>RLESeqT</a> data into stack.
pushSTRLESeqT :: STRLESeqT s (Maybe Text) -> Maybe Text -> ST s ()

-- | State function to create empty <a>STRLESeqT</a> type.
emptySTRLESeqT :: ST s (STRLESeqT s a)

-- | Abstract <a>STRLETempT</a> state type.
type STRLETempT s a = STRef s (Maybe Text)

-- | State function to update <a>STRLETempT</a>.
updateSTRLETempT :: STRLETempT s (Maybe Text) -> Maybe Text -> ST s ()

-- | State function to create empty <a>STRLETempT</a> type.
emptySTRLETempT :: ST s (STRLETempT s a)

-- | Abstract <a>STRLECounterT</a> and associated state type.
type STRLECounterT s a = STRef s Int

-- | State function to update <a>STRLECounterT</a>.
updateSTRLECounterT :: STRLECounterT s Int -> Int -> ST s ()

-- | State function to create empty <a>STRLECounterT</a> type.
emptySTRLECounterT :: ST s (STRLECounterT s Int)

-- | Strict state monad function.
seqToRLET :: RLESeqT -> ST s RLESeqT

-- | Abstract <a>FRLESeqB</a> type utilizing a <a>Seq</a>.
type FRLESeqB = Seq (Maybe ByteString)

-- | Abstract data type representing a <a>FRLESeqB</a> in the (strict) ST
--   monad.
type FSTRLESeqB s a = STRef s FRLESeqB

-- | State function to push <a>FRLESeqB</a> data into stack.
pushFSTRLESeqB :: FSTRLESeqB s (Maybe ByteString) -> Maybe ByteString -> ST s ()

-- | State function to create empty <a>FSTRLESeqB</a> type.
emptyFSTRLESeqB :: ST s (FSTRLESeqB s a)

-- | Strict state monad function.
seqFromRLEB :: RLEB -> ST s FRLESeqB

-- | Abstract <a>FRLESeqT</a> type utilizing a <a>Seq</a>.
type FRLESeqT = Seq (Maybe Text)

-- | Abstract data type representing a <a>FRLESeqT</a> in the (strict) ST
--   monad.
type FSTRLESeqT s a = STRef s FRLESeqT

-- | State function to push <a>FSTRLESeqT</a> data into stack.
pushFSTRLESeqT :: FSTRLESeqT s (Maybe Text) -> Maybe Text -> ST s ()

-- | State function to create empty <a>FSTRLESeqT</a> type.
emptyFSTRLESeqT :: ST s (FSTRLESeqT s a)

-- | Strict state monad function.
seqFromRLET :: RLET -> ST s FRLESeqT
instance GHC.Generics.Generic Data.RLE.Internal.RLEB
instance GHC.Read.Read Data.RLE.Internal.RLEB
instance GHC.Show.Show Data.RLE.Internal.RLEB
instance GHC.Classes.Ord Data.RLE.Internal.RLEB
instance GHC.Classes.Eq Data.RLE.Internal.RLEB
instance GHC.Generics.Generic Data.RLE.Internal.RLET
instance GHC.Read.Read Data.RLE.Internal.RLET
instance GHC.Show.Show Data.RLE.Internal.RLET
instance GHC.Classes.Ord Data.RLE.Internal.RLET
instance GHC.Classes.Eq Data.RLE.Internal.RLET


-- | <h1>Run-length encoding (RLE)</h1>
--   
--   Users will get the most mileage by first compressing to a <a>BWT</a>
--   on the initial <a>ByteString</a> or <a>Text</a> input before
--   compressing to a <a>RLEB</a> or <a>RLET</a>.
--   
--   To do this, users can use the <a>bytestringToBWTToRLEB</a> and
--   <a>bytestringToBWTToRLET</a> functions, as well as the
--   <a>textToBWTToRLEB</a> and <a>textToBWTToRLET</a> functions.
--   
--   The base functions for <a>ByteString</a>, <a>bytestringToRLEB</a> and
--   <a>bytestringToRLET</a> can be used to convert a <a>Seq</a>
--   (<a>Maybe</a> <a>ByteString</a>) to a <a>RLEB</a> and <a>RLET</a>,
--   respectively.
--   
--   Likewise, the base functions for <a>Text</a>, <a>textToRLEB</a> and
--   <a>textToRLET</a> can be used to convert a <a>Seq</a> (<a>Maybe</a>
--   <a>Text</a>) to a <a>RLEB</a> and <a>RLET</a> respectively.
--   
--   There are various other lower-level functions for interacting with the
--   RLE implementation on <a>ByteString</a> and <a>Text</a> as well.
--   
--   <tt><a>Data.RLE.Internal</a></tt> contains efficient and stateful
--   implementations of the RLE and Inverse RLE algorithms.
module Data.RLE

-- | Helper function for converting a <a>ByteString</a> to a <a>RLEB</a>
--   via a <a>BWT</a> first.
bytestringToBWTToRLEB :: ByteString -> RLEB

-- | Helper function for converting a <a>ByteString</a> to a <a>RLET</a>
--   via a <a>BWT</a> first.
bytestringToBWTToRLET :: ByteString -> RLET

-- | Helper function for converting a <a>Text</a> to a <a>RLEB</a> via a
--   <a>BWT</a> first.
textToBWTToRLEB :: Text -> RLEB

-- | Helper function for converting a <a>Text</a> to a <a>RLET</a> via a
--   <a>BWT</a> first.
textToBWTToRLET :: Text -> RLET

-- | Take a <a>BWT</a> of <a>Word8</a>s and generate the Run-length
--   encoding (<a>RLEB</a>).
textBWTToRLEB :: TextBWT -> RLEB

-- | Take a <a>BWT</a> of <a>Word8</a>s and generate the Run-length
--   encoding (<a>RLEB</a>).
bytestringBWTToRLEB :: BWT Word8 -> RLEB

-- | Take a <a>BWT</a> of <a>Word8</a>s and generate the Run-length
--   encoding (<a>RLEB</a>).
textBWTToRLET :: TextBWT -> RLET

-- | Take a <a>BWT</a> of <a>Word8</a>s and generate the Run-length
--   encoding (<a>RLET</a>).
bytestringBWTToRLET :: BWT Word8 -> RLET

-- | Takes a <a>Text</a> and returns the Run-length encoding (<a>RLEB</a>).
textToRLEB :: Seq (Maybe Text) -> RLEB

-- | Takes a <a>Seq</a> of <a>ByteString</a>s and returns the Run-length
--   encoding (<a>RLEB</a>).
bytestringToRLEB :: Seq (Maybe ByteString) -> RLEB

-- | Takes a <a>Text</a> and returns the Run-length encoding (RLE).
textToRLET :: Seq (Maybe Text) -> RLET

-- | Takes a <a>ByteString</a> and returns the Run-length encoding (RLE).
bytestringToRLET :: Seq (Maybe ByteString) -> RLET

-- | Helper function for converting a <a>BWT</a>ed <a>RLEB</a> back to the
--   original <a>ByteString</a>.
bytestringFromBWTFromRLEB :: RLEB -> ByteString

-- | Helper function for converting a <a>BWT</a>ed <a>RLET</a> back to the
--   original <a>ByteString</a>.
bytestringFromBWTFromRLET :: RLET -> ByteString

-- | Helper function for converting a <a>BWT</a>ed <a>RLEB</a> back to the
--   original <a>Text</a>.
textFromBWTFromRLEB :: RLEB -> Text

-- | Helper function for converting a <a>BWT</a>ed <a>RLET</a> back to the
--   original <a>Text</a>.
textFromBWTFromRLET :: RLET -> Text

-- | Takes a <a>RLET</a> and returns the <a>BWT</a> of <a>Text</a>s.
textBWTFromRLET :: RLET -> BWT Text

-- | Takes a <a>RLET</a> and returns the <a>BWT</a> of <a>ByteString</a>s.
bytestringBWTFromRLET :: RLET -> BWT ByteString

-- | Takes a <a>RLEB</a> and returns the <a>BWT</a> of <a>Text</a>s.
textBWTFromRLEB :: RLEB -> BWT Text

-- | Take a <a>RLEB</a> and returns the <a>BWT</a> of <a>ByteString</a>s.
bytestringBWTFromRLEB :: RLEB -> BWT ByteString

-- | Takes a <a>RLEB</a> and returns the original <a>Seq</a> of
--   <a>Text</a>s.
textFromRLEB :: RLEB -> Seq (Maybe Text)

-- | Takes a <a>RLEB</a> and returns the original <a>Seq</a> of
--   <a>ByteString</a>s.
bytestringFromRLEB :: RLEB -> Seq (Maybe ByteString)

-- | Takes a <a>RLET</a> and returns the original <a>Seq</a> of
--   <a>Text</a>s.
textFromRLET :: RLET -> Seq (Maybe Text)

-- | Takes a <a>RLET</a> and returns the original <a>Seq</a> of
--   <a>ByteString</a>s.
bytestringFromRLET :: RLET -> Seq (Maybe ByteString)