{-# LANGUAGE MultiWayIf        #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ViewPatterns      #-}
{-# LANGUAGE Strict            #-}


-- |
-- Module      :  Data.MTF
-- Copyright   :  (c) Matthew Mosior 2022
-- License     :  BSD-style
-- Maintainer  :  mattm.github@gmail.com
-- Portability :  portable
--
-- = Move-to-front transform (MTF)
--
-- Users will get the most mileage by first compressing to a 'BWT'
-- on the initial 'ByteString' or 'Text' input before compressing to
-- a 'MTFB' or 'MTFT'.
--
-- To do this, users can use the 'bytestringToBWTToMTFB' and 'bytestringToBWTToMTFT' functions,
-- as well as the 'textToBWTToMTFB' and 'textToBWTToMTFT' functions.
--
-- The base functions for 'ByteString', 'bytestringToMTFB' and 'bytestringToMTFT' can be used to
-- convert a 'Seq' ('Maybe' 'ByteString') to a 'MTFB' and 'MTFT', respectively.
--
-- Likewise, the base functions for 'Text', 'textToMTFB' and 'textToMTFT' can be used to
-- convert a 'Seq' ('Maybe' 'Text') to a 'MTFB' and 'MTFT' respectively.
--
-- There are various other lower-level functions for interacting with the MTF implementation on 'ByteString' and 'Text' as well.
--
-- @"Data.MTF.Internal"@ contains efficient and stateful implementations of the MTF and Inverse MTF algorithms.


module Data.MTF ( -- * To MTF functions
                  bytestringToBWTToMTFB,
                  bytestringToBWTToMTFT,
                  textToBWTToMTFB,
                  textToBWTToMTFT,
                  textBWTToMTFB,
                  bytestringBWTToMTFB,
                  textBWTToMTFT,
                  bytestringBWTToMTFT,
                  textToMTFB,
                  bytestringToMTFB,
                  textToMTFT,
                  bytestringToMTFT,
                  -- * From MTF functions
                  bytestringFromBWTFromMTFB,
                  bytestringFromBWTFromMTFT,
                  textFromBWTFromMTFB,
                  textFromBWTFromMTFT,
                  textBWTFromMTFT,
                  bytestringBWTFromMTFT,
                  textBWTFromMTFB,
                  bytestringBWTFromMTFB,
                  textFromMTFB,
                  bytestringFromMTFB,
                  textFromMTFT,
                  bytestringFromMTFT
                ) where

import Data.BWT
import Data.BWT.Internal 
import Data.MTF.Internal

import Control.Monad()
import Control.Monad.ST as CMST
import Control.Monad.State.Strict()
import Data.ByteString as BS
import Data.ByteString.Char8()
import Data.Char()
import Data.Foldable()
import Data.Maybe as DMaybe (isNothing,fromJust)
import Data.Sequence as DS (Seq(..))
import Data.STRef()
import Data.Text as DText 
import Data.Text.Encoding as DTE (decodeUtf8,encodeUtf8)
import Data.Word (Word8)
import Prelude as P


{-toMTF Function(s)-}

-- | Helper function for converting a 'ByteString'
-- to a 'MTFB' via a 'BWT' first.
bytestringToBWTToMTFB :: ByteString ->
                         MTFB
bytestringToBWTToMTFB :: ByteString -> MTFB
bytestringToBWTToMTFB = BWT Word8 -> MTFB
bytestringBWTToMTFB forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BWT Word8
bytestringToBWT

-- | Helper function for converting a 'ByteString'
-- to a 'MTFT' via a 'BWT' first.
bytestringToBWTToMTFT :: ByteString ->
                         MTFT
bytestringToBWTToMTFT :: ByteString -> MTFT
bytestringToBWTToMTFT = BWT Word8 -> MTFT
bytestringBWTToMTFT forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BWT Word8
bytestringToBWT

-- | Helper function for converting a 'Text'
-- to a 'MTFB' via a 'BWT' first.
textToBWTToMTFB :: Text ->
                   MTFB
textToBWTToMTFB :: Text -> MTFB
textToBWTToMTFB = TextBWT -> MTFB
textBWTToMTFB forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> TextBWT
textToBWT

-- | Helper function for converting a 'Text'
-- to a 'MTFT' via a 'BWT' first.
textToBWTToMTFT :: Text ->
                   MTFT
textToBWTToMTFT :: Text -> MTFT
textToBWTToMTFT = TextBWT -> MTFT
textBWTToMTFT forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> TextBWT
textToBWT

-- | Take a 'BWT' of 'Word8's and generate the
-- Move-to-front transform ('MTFB').
textBWTToMTFB :: TextBWT
              -> MTFB
textBWTToMTFB :: TextBWT -> MTFB
textBWTToMTFB TextBWT
xs =
  (Seq Int, Seq (Maybe ByteString)) -> MTFB
MTFB (forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s.
Seq (Maybe ByteString) -> ST s (Seq Int, Seq (Maybe ByteString))
seqToMTFB Seq (Maybe ByteString)
xss)
    where
      xss :: Seq (Maybe ByteString)
xss = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Word8
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Word8
x
                           -> forall a. Maybe a
Nothing
                           | Bool
otherwise
                           -> forall a. a -> Maybe a
Just         forall a b. (a -> b) -> a -> b
$
                              Word8 -> ByteString
BS.singleton forall a b. (a -> b) -> a -> b
$
                              forall a. HasCallStack => Maybe a -> a
fromJust Maybe Word8
x
                 )
            ((\(BWT Seq (Maybe Word8)
t) -> Seq (Maybe Word8)
t) forall a b. (a -> b) -> a -> b
$
            ((\(TextBWT BWT Word8
t) -> BWT Word8
t) TextBWT
xs))

-- | Take a 'BWT' of 'Word8's and generate the
-- Move-to-front transform ('MTFB').
bytestringBWTToMTFB :: BWT Word8
                    -> MTFB
bytestringBWTToMTFB :: BWT Word8 -> MTFB
bytestringBWTToMTFB BWT Word8
xs =
  (Seq Int, Seq (Maybe ByteString)) -> MTFB
MTFB (forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s.
Seq (Maybe ByteString) -> ST s (Seq Int, Seq (Maybe ByteString))
seqToMTFB Seq (Maybe ByteString)
xss)
    where
      xss :: Seq (Maybe ByteString)
xss = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Word8
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Word8
x
                           -> forall a. Maybe a
Nothing
                           | Bool
otherwise
                           -> forall a. a -> Maybe a
Just         forall a b. (a -> b) -> a -> b
$
                              Word8 -> ByteString
BS.singleton forall a b. (a -> b) -> a -> b
$
                              forall a. HasCallStack => Maybe a -> a
fromJust Maybe Word8
x
                 )
            ((\(BWT Seq (Maybe Word8)
t) -> Seq (Maybe Word8)
t) BWT Word8
xs)

-- | Take a 'BWT' of 'Word8's and generate the
-- Move-to-front transform ('MTFB').
textBWTToMTFT :: TextBWT
              -> MTFT
textBWTToMTFT :: TextBWT -> MTFT
textBWTToMTFT TextBWT
xs =
  (Seq Int, Seq (Maybe Text)) -> MTFT
MTFT (forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. Seq (Maybe Text) -> ST s (Seq Int, Seq (Maybe Text))
seqToMTFT Seq (Maybe Text)
xss)
    where
      xss :: Seq (Maybe Text)
xss = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Word8
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Word8
x
                           -> forall a. Maybe a
Nothing
                           | Bool
otherwise
                           -> forall a. a -> Maybe a
Just           forall a b. (a -> b) -> a -> b
$
                              ByteString -> Text
DTE.decodeUtf8 forall a b. (a -> b) -> a -> b
$
                              Word8 -> ByteString
BS.singleton   forall a b. (a -> b) -> a -> b
$
                              forall a. HasCallStack => Maybe a -> a
fromJust Maybe Word8
x
                 )
            ((\(BWT Seq (Maybe Word8)
t) -> Seq (Maybe Word8)
t) forall a b. (a -> b) -> a -> b
$
            ((\(TextBWT BWT Word8
t) -> BWT Word8
t) TextBWT
xs))

-- | Take a 'BWT' of 'Word8's and generate the
-- Move-to-front transform ('MTFT').
bytestringBWTToMTFT :: BWT Word8
                    -> MTFT
bytestringBWTToMTFT :: BWT Word8 -> MTFT
bytestringBWTToMTFT BWT Word8
xs =
  (Seq Int, Seq (Maybe Text)) -> MTFT
MTFT (forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. Seq (Maybe Text) -> ST s (Seq Int, Seq (Maybe Text))
seqToMTFT Seq (Maybe Text)
xss)
    where
      xss :: Seq (Maybe Text)
xss = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Word8
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Word8
x
                           -> forall a. Maybe a
Nothing
                           | Bool
otherwise
                           -> forall a. a -> Maybe a
Just           forall a b. (a -> b) -> a -> b
$
                              ByteString -> Text
DTE.decodeUtf8 forall a b. (a -> b) -> a -> b
$
                              Word8 -> ByteString
BS.singleton   forall a b. (a -> b) -> a -> b
$
                              forall a. HasCallStack => Maybe a -> a
fromJust Maybe Word8
x
                 )
            ((\(BWT Seq (Maybe Word8)
t) -> Seq (Maybe Word8)
t) BWT Word8
xs)

-- | Takes a 'Text' and returns the Move-to-front transform ('MTFB').
textToMTFB :: Seq (Maybe Text)
           -> MTFB
textToMTFB :: Seq (Maybe Text) -> MTFB
textToMTFB Seq (Maybe Text)
DS.Empty = (Seq Int, Seq (Maybe ByteString)) -> MTFB
MTFB (forall a. Seq a
DS.Empty,forall a. Seq a
DS.Empty)
textToMTFB Seq (Maybe Text)
xs       = 
  (Seq Int, Seq (Maybe ByteString)) -> MTFB
MTFB (forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s.
Seq (Maybe ByteString) -> ST s (Seq Int, Seq (Maybe ByteString))
seqToMTFB Seq (Maybe ByteString)
xss)
    where
      xss :: Seq (Maybe ByteString)
xss = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Text
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Text
x
                           -> forall a. Maybe a
Nothing
                           | Bool
otherwise
                           -> forall a. a -> Maybe a
Just            forall a b. (a -> b) -> a -> b
$
                               Text -> ByteString
DTE.encodeUtf8 forall a b. (a -> b) -> a -> b
$
                               forall a. HasCallStack => Maybe a -> a
fromJust Maybe Text
x
                 )
            Seq (Maybe Text)
xs

-- | Takes a 'Seq' of 'ByteString's and returns the Move-to-front transform ('MTFB').
bytestringToMTFB :: Seq (Maybe ByteString)
                 -> MTFB
bytestringToMTFB :: Seq (Maybe ByteString) -> MTFB
bytestringToMTFB Seq (Maybe ByteString)
DS.Empty = (Seq Int, Seq (Maybe ByteString)) -> MTFB
MTFB (forall a. Seq a
DS.Empty,forall a. Seq a
DS.Empty)
bytestringToMTFB Seq (Maybe ByteString)
xs       =
 (Seq Int, Seq (Maybe ByteString)) -> MTFB
MTFB (forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s.
Seq (Maybe ByteString) -> ST s (Seq Int, Seq (Maybe ByteString))
seqToMTFB Seq (Maybe ByteString)
xs)

-- | Takes a 'Text' and returns the Move-to-front transform ('MTFT').
textToMTFT :: Seq (Maybe Text)
           -> MTFT
textToMTFT :: Seq (Maybe Text) -> MTFT
textToMTFT Seq (Maybe Text)
DS.Empty = (Seq Int, Seq (Maybe Text)) -> MTFT
MTFT (forall a. Seq a
DS.Empty,forall a. Seq a
DS.Empty)
textToMTFT Seq (Maybe Text)
xs       =
  (Seq Int, Seq (Maybe Text)) -> MTFT
MTFT (forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. Seq (Maybe Text) -> ST s (Seq Int, Seq (Maybe Text))
seqToMTFT Seq (Maybe Text)
xs)

-- | Takes a 'ByteString' and returns the Move-to-front transform ('MTFT').
bytestringToMTFT :: Seq (Maybe ByteString)
                 -> MTFT
bytestringToMTFT :: Seq (Maybe ByteString) -> MTFT
bytestringToMTFT Seq (Maybe ByteString)
DS.Empty = (Seq Int, Seq (Maybe Text)) -> MTFT
MTFT (forall a. Seq a
DS.Empty,forall a. Seq a
DS.Empty)
bytestringToMTFT Seq (Maybe ByteString)
xs       =
  (Seq Int, Seq (Maybe Text)) -> MTFT
MTFT (forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. Seq (Maybe Text) -> ST s (Seq Int, Seq (Maybe Text))
seqToMTFT Seq (Maybe Text)
xss)
    where
      xss :: Seq (Maybe Text)
xss = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe ByteString
x -> if | forall a. Maybe a -> Bool
isNothing Maybe ByteString
x
                           -> forall a. Maybe a
Nothing
                           | Bool
otherwise
                           -> forall a. a -> Maybe a
Just           forall a b. (a -> b) -> a -> b
$
                              ByteString -> Text
DTE.decodeUtf8 forall a b. (a -> b) -> a -> b
$
                              forall a. HasCallStack => Maybe a -> a
fromJust Maybe ByteString
x
                 )
            Seq (Maybe ByteString)
xs 

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


{-fromMTF function(s)-}

-- | Helper function for converting a 'BWT'ed 'MTFB'
-- back to the original 'ByteString'.
bytestringFromBWTFromMTFB :: MTFB 
                          -> ByteString
bytestringFromBWTFromMTFB :: MTFB -> ByteString
bytestringFromBWTFromMTFB = BWT ByteString -> ByteString
bytestringFromByteStringBWT forall b c a. (b -> c) -> (a -> b) -> a -> c
. MTFB -> BWT ByteString
bytestringBWTFromMTFB

-- | Helper function for converting a 'BWT'ed 'MTFT'
-- back to the original 'ByteString'.
bytestringFromBWTFromMTFT :: MTFT
                          -> ByteString
bytestringFromBWTFromMTFT :: MTFT -> ByteString
bytestringFromBWTFromMTFT MTFT
xs = BWT ByteString -> ByteString
bytestringFromByteStringBWT forall a b. (a -> b) -> a -> b
$
                               forall a. Seq (Maybe a) -> BWT a
BWT                         forall a b. (a -> b) -> a -> b
$
                               forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Text
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Text
x
                                              -> forall a. Maybe a
Nothing
                                              | Bool
otherwise
                                              -> forall a. a -> Maybe a
Just           forall a b. (a -> b) -> a -> b
$
                                                 Text -> ByteString
DTE.encodeUtf8 forall a b. (a -> b) -> a -> b
$
                                                 forall a. HasCallStack => Maybe a -> a
fromJust Maybe Text
x
                                    )
                                                           forall a b. (a -> b) -> a -> b
$
                            ((\(BWT Seq (Maybe Text)
t) -> Seq (Maybe Text)
t) (MTFT -> BWT Text
textBWTFromMTFT MTFT
xs))

-- | Helper function for converting a 'BWT'ed 'MTFB'
-- back to the original 'Text'.
textFromBWTFromMTFB :: MTFB
                    -> Text
textFromBWTFromMTFB :: MTFB -> Text
textFromBWTFromMTFB = ByteString -> Text
DTE.decodeUtf8 forall b c a. (b -> c) -> (a -> b) -> a -> c
. BWT ByteString -> ByteString
bytestringFromByteStringBWT forall b c a. (b -> c) -> (a -> b) -> a -> c
. MTFB -> BWT ByteString
bytestringBWTFromMTFB

-- | Helper function for converting a 'BWT'ed 'MTFT'
-- back to the original 'Text'.
textFromBWTFromMTFT :: MTFT
                    -> Text
textFromBWTFromMTFT :: MTFT -> Text
textFromBWTFromMTFT = ByteString -> Text
DTE.decodeUtf8 forall b c a. (b -> c) -> (a -> b) -> a -> c
. BWT ByteString -> ByteString
bytestringFromByteStringBWT forall b c a. (b -> c) -> (a -> b) -> a -> c
. MTFT -> BWT ByteString
bytestringBWTFromMTFT

-- | Takes a 'MTFT' and returns
-- the 'BWT' of 'Text's.
textBWTFromMTFT :: MTFT
                -> BWT Text
textBWTFromMTFT :: MTFT -> BWT Text
textBWTFromMTFT (MTFT (Seq Int
DS.Empty,Seq (Maybe Text)
_)) = forall a. Seq (Maybe a) -> BWT a
BWT forall a. Seq a
DS.Empty
textBWTFromMTFT (MTFT (Seq Int
_,Seq (Maybe Text)
DS.Empty)) = forall a. Seq (Maybe a) -> BWT a
BWT forall a. Seq a
DS.Empty
textBWTFromMTFT MTFT
xs                  = 
  forall a. Seq (Maybe a) -> BWT a
BWT (forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. MTFT -> ST s (Seq (Maybe Text))
seqFromMTFT MTFT
xs)

-- | Takes a 'MTFT' and returns
-- the 'BWT' of 'ByteString's.
bytestringBWTFromMTFT :: MTFT
                      -> BWT ByteString
bytestringBWTFromMTFT :: MTFT -> BWT ByteString
bytestringBWTFromMTFT (MTFT (Seq Int
DS.Empty,Seq (Maybe Text)
_)) = forall a. Seq (Maybe a) -> BWT a
BWT forall a. Seq a
DS.Empty
bytestringBWTFromMTFT (MTFT (Seq Int
_,Seq (Maybe Text)
DS.Empty)) = forall a. Seq (Maybe a) -> BWT a
BWT forall a. Seq a
DS.Empty
bytestringBWTFromMTFT MTFT
xs                  = do
  let originalbwtb :: Seq (Maybe Text)
originalbwtb = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. MTFT -> ST s (Seq (Maybe Text))
seqFromMTFT MTFT
xs
  forall a. Seq (Maybe a) -> BWT a
BWT (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Text
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Text
x
                      -> forall a. Maybe a
Nothing
                      | Bool
otherwise
                      -> forall a. a -> Maybe a
Just           forall a b. (a -> b) -> a -> b
$
                         Text -> ByteString
DTE.encodeUtf8 forall a b. (a -> b) -> a -> b
$
                        forall a. HasCallStack => Maybe a -> a
fromJust Maybe Text
x 
            ) Seq (Maybe Text)
originalbwtb)

-- | Takes a 'MTFB' and returns
-- the 'BWT' of 'Text's.
textBWTFromMTFB :: MTFB
                -> BWT Text
textBWTFromMTFB :: MTFB -> BWT Text
textBWTFromMTFB (MTFB (Seq Int
DS.Empty,Seq (Maybe ByteString)
_)) = forall a. Seq (Maybe a) -> BWT a
BWT forall a. Seq a
DS.Empty
textBWTFromMTFB (MTFB (Seq Int
_,Seq (Maybe ByteString)
DS.Empty)) = forall a. Seq (Maybe a) -> BWT a
BWT forall a. Seq a
DS.Empty
textBWTFromMTFB MTFB
xs                  = do
  let originalbwtt :: Seq (Maybe ByteString)
originalbwtt = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. MTFB -> ST s (Seq (Maybe ByteString))
seqFromMTFB MTFB
xs
  forall a. Seq (Maybe a) -> BWT a
BWT (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe ByteString
x -> if | forall a. Maybe a -> Bool
isNothing Maybe ByteString
x
                      -> forall a. Maybe a
Nothing
                      | Bool
otherwise
                      -> forall a. a -> Maybe a
Just           forall a b. (a -> b) -> a -> b
$
                         ByteString -> Text
DTE.decodeUtf8 forall a b. (a -> b) -> a -> b
$
                        forall a. HasCallStack => Maybe a -> a
fromJust Maybe ByteString
x
            ) Seq (Maybe ByteString)
originalbwtt)

-- | Take a 'MTFB' and returns
-- the 'BWT' of 'ByteString's.
bytestringBWTFromMTFB :: MTFB 
                      -> BWT ByteString
bytestringBWTFromMTFB :: MTFB -> BWT ByteString
bytestringBWTFromMTFB (MTFB (Seq Int
DS.Empty,Seq (Maybe ByteString)
_)) = forall a. Seq (Maybe a) -> BWT a
BWT forall a. Seq a
DS.Empty
bytestringBWTFromMTFB (MTFB (Seq Int
_,Seq (Maybe ByteString)
DS.Empty)) = forall a. Seq (Maybe a) -> BWT a
BWT forall a. Seq a
DS.Empty
bytestringBWTFromMTFB MTFB
xs              =
  forall a. Seq (Maybe a) -> BWT a
BWT (forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. MTFB -> ST s (Seq (Maybe ByteString))
seqFromMTFB MTFB
xs)

-- | Takes a 'MTFB' and returns
-- the original 'Seq' of 'Text's.
textFromMTFB :: MTFB
             -> Seq (Maybe Text)
textFromMTFB :: MTFB -> Seq (Maybe Text)
textFromMTFB (MTFB (Seq Int
DS.Empty,Seq (Maybe ByteString)
_)) = forall a. Seq a
DS.Empty
textFromMTFB (MTFB (Seq Int
_,Seq (Maybe ByteString)
DS.Empty)) = forall a. Seq a
DS.Empty
textFromMTFB MTFB
xs                  = do
  let originalt :: Seq (Maybe ByteString)
originalt = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. MTFB -> ST s (Seq (Maybe ByteString))
seqFromMTFB MTFB
xs
  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe ByteString
x -> if | forall a. Maybe a -> Bool
isNothing Maybe ByteString
x
                 -> forall a. Maybe a
Nothing
                 | Bool
otherwise
                 -> forall a. a -> Maybe a
Just           forall a b. (a -> b) -> a -> b
$
                    ByteString -> Text
DTE.decodeUtf8 forall a b. (a -> b) -> a -> b
$
                    forall a. HasCallStack => Maybe a -> a
fromJust Maybe ByteString
x
       ) Seq (Maybe ByteString)
originalt

-- | Takes a 'MTFB' and returns
-- the original 'Seq' of 'ByteString's.
bytestringFromMTFB :: MTFB
                   -> Seq (Maybe ByteString)
bytestringFromMTFB :: MTFB -> Seq (Maybe ByteString)
bytestringFromMTFB (MTFB (Seq Int
DS.Empty,Seq (Maybe ByteString)
_)) = forall a. Seq a
DS.Empty
bytestringFromMTFB (MTFB (Seq Int
_,Seq (Maybe ByteString)
DS.Empty)) = forall a. Seq a
DS.Empty
bytestringFromMTFB MTFB
xs                  =
  forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. MTFB -> ST s (Seq (Maybe ByteString))
seqFromMTFB MTFB
xs

-- | Takes a 'MTFT' and returns
-- the original 'Seq' of 'Text's.
textFromMTFT :: MTFT
             -> Seq (Maybe Text)
textFromMTFT :: MTFT -> Seq (Maybe Text)
textFromMTFT (MTFT (Seq Int
DS.Empty,Seq (Maybe Text)
_)) = forall a. Seq a
DS.Empty
textFromMTFT (MTFT (Seq Int
_,Seq (Maybe Text)
DS.Empty)) = forall a. Seq a
DS.Empty
textFromMTFT MTFT
xs                  =
  forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. MTFT -> ST s (Seq (Maybe Text))
seqFromMTFT MTFT
xs

-- | Takes a 'MTFT' and returns
-- the original 'Seq' of 'ByteString's.
bytestringFromMTFT :: MTFT
                   -> Seq (Maybe ByteString)
bytestringFromMTFT :: MTFT -> Seq (Maybe ByteString)
bytestringFromMTFT (MTFT (Seq Int
DS.Empty,Seq (Maybe Text)
_)) = forall a. Seq a
DS.Empty
bytestringFromMTFT (MTFT (Seq Int
_,Seq (Maybe Text)
DS.Empty)) = forall a. Seq a
DS.Empty
bytestringFromMTFT MTFT
xs                  = do
  let originalb :: Seq (Maybe Text)
originalb = forall a. (forall s. ST s a) -> a
CMST.runST forall a b. (a -> b) -> a -> b
$ forall s. MTFT -> ST s (Seq (Maybe Text))
seqFromMTFT MTFT
xs
  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Text
x -> if | forall a. Maybe a -> Bool
isNothing Maybe Text
x
                 -> forall a. Maybe a
Nothing
                 | Bool
otherwise
                 -> forall a. a -> Maybe a
Just           forall a b. (a -> b) -> a -> b
$ 
                    Text -> ByteString
DTE.encodeUtf8 forall a b. (a -> b) -> a -> b
$
                    forall a. HasCallStack => Maybe a -> a
fromJust Maybe Text
x
       ) Seq (Maybe Text)
originalb

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