{-# OPTIONS_GHC -fno-warn-orphans #-}

module Bio.FASTA.Parser
  ( fastaP
  , fastaLine
  , parseOnly
  , modificationP
  , fastaPGeneric
  , Parser
  ) where

import           Bio.FASTA.Type             (Fasta, FastaItem (..),
                                             ModItem (..), Modification (..),
                                             ParsableFastaToken (..))
import           Bio.Sequence               (BareSequence, bareSequence)
import           Data.Bifunctor             (first)
import           Data.Char                  (isLetter)
import           Data.Functor               (void, ($>))
import           Data.Text                  (Text, pack, strip)
import           Data.Void                  (Void)
import           Text.Megaparsec
import           Text.Megaparsec.Char
import qualified Text.Megaparsec.Char.Lexer as L

instance ParsableFastaToken Char where
  parseToken :: (Char -> Bool) -> Parsec Void Text Char
parseToken Char -> Bool
p = forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
satisfy Char -> Bool
p forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> String -> m a
<?> String
"letter"

instance ParsableFastaToken ModItem where
  parseToken :: (Char -> Bool) -> Parsec Void Text ModItem
parseToken Char -> Bool
p = (Modification -> ModItem
Mod forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Modification
modificationP forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> String -> m a
<?> String
"fasta item modification") forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Char -> ModItem
Letter forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
satisfy Char -> Bool
p forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> String -> m a
<?> String
"letter")

type Parser = Parsec Void Text

-- | Parser of .fasta file.
--

parseOnly :: Parsec Void Text a -> Text -> Either String a
parseOnly :: forall a. Parsec Void Text a -> Text -> Either String a
parseOnly Parsec Void Text a
p Text
s = forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first forall s e.
(VisualStream s, TraversableStream s, ShowErrorComponent e) =>
ParseErrorBundle s e -> String
errorBundlePretty forall a b. (a -> b) -> a -> b
$ forall e s a.
Parsec e s a -> String -> s -> Either (ParseErrorBundle s e) a
parse Parsec Void Text a
p String
"input.fasta" Text
s

sc :: Parser ()
sc :: Parser ()
sc = forall e s (m :: * -> *).
MonadParsec e s m =>
m () -> m () -> m () -> m ()
L.space forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
space1 forall (f :: * -> *) a. Alternative f => f a
empty forall (f :: * -> *) a. Alternative f => f a
empty

lexeme :: Parser a -> Parser a
lexeme :: forall a. Parser a -> Parser a
lexeme = forall e s (m :: * -> *) a. MonadParsec e s m => m () -> m a -> m a
L.lexeme Parser ()
sc

symbol :: Text -> Parser Text
symbol :: Text -> Parser Text
symbol = forall e s (m :: * -> *).
MonadParsec e s m =>
m () -> Tokens s -> m (Tokens s)
L.symbol Parser ()
sc

fastaP :: ParsableFastaToken a => Parser (Fasta a)
fastaP :: forall a. ParsableFastaToken a => Parser (Fasta a)
fastaP = forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (forall a.
ParsableFastaToken a =>
(Char -> Bool) -> Parser (FastaItem a)
item Char -> Bool
isLetter) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
hidden forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *). MonadParsec e s m => m ()
eof

fastaPGeneric :: ParsableFastaToken a => (Char -> Bool) -> Parser (Fasta a)
fastaPGeneric :: forall a.
ParsableFastaToken a =>
(Char -> Bool) -> Parser (Fasta a)
fastaPGeneric Char -> Bool
p  = forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (forall a.
ParsableFastaToken a =>
(Char -> Bool) -> Parser (FastaItem a)
item Char -> Bool
p) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
hidden forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
space forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *). MonadParsec e s m => m ()
eof

item :: ParsableFastaToken a => (Char -> Bool) -> Parser (FastaItem a)
item :: forall a.
ParsableFastaToken a =>
(Char -> Bool) -> Parser (FastaItem a)
item Char -> Bool
p =
  forall a. Text -> BareSequence a -> FastaItem a
FastaItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
seqName
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall a.
ParsableFastaToken a =>
(Char -> Bool) -> Parser (BareSequence a)
fastaSeq Char -> Bool
p forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> String -> m a
<?> String
"sequence")

seqName :: Parser Text
seqName :: Parser Text
seqName = Text -> Text
strip forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
pack forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Text -> Parser Text
symbol Text
">" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
manyTill forall e s (m :: * -> *). MonadParsec e s m => m (Token s)
anySingle Parser ()
myEnd forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> String -> m a
<?> String
"sequence name"))

fastaSeq :: ParsableFastaToken a => (Char -> Bool) -> Parser (BareSequence a)
fastaSeq :: forall a.
ParsableFastaToken a =>
(Char -> Bool) -> Parser (BareSequence a)
fastaSeq Char -> Bool
p = forall s. IsBareSequence s => [Element s] -> s
bareSequence forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (forall a. ParsableFastaToken a => (Char -> Bool) -> Parser [a]
fastaLine Char -> Bool
p) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
hidden forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
space

fastaLine :: ParsableFastaToken a => (Char -> Bool) -> Parser [a]
fastaLine :: forall a. ParsableFastaToken a => (Char -> Bool) -> Parser [a]
fastaLine Char -> Bool
p = forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some (forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some (forall a.
ParsableFastaToken a =>
(Char -> Bool) -> Parsec Void Text a
parseToken Char -> Bool
p) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
hidden forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser ()
myEnd

myEnd :: Parser ()
myEnd :: Parser ()
myEnd = forall (f :: * -> *) a. Functor f => f a -> f ()
void (forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Tokens s)
eol) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *). MonadParsec e s m => m ()
eof

modificationP :: Parser Modification
modificationP :: Parser Modification
modificationP
  = forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
choice
  [ forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[A*]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_A_Star
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[C*]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_C_Star
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[G*]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_G_Star
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[T*]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_T_Star
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[rA]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_rA
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[rC]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_rC
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[rG]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_rG
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[rU]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_rU
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[+A]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_Plus_A
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[+C]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_Plus_C
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[+G]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_Plus_G
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[+T]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_Plus_T
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[rAf]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_rAf
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[rCf]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_rCf
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[rGf]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_rGf
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[rUf]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_rUf
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[mA]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_mA
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[mC]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_mC
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[mG]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_mG
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[mU]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_mU
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[mA*]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_mA_Star
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[mC*]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_mC_Star
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[mG*]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_mG_Star
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[mU*]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_mU_Star
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[dU]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_dU
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[5Bio]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_5Bio
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[iBio]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_iBio
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[56FAM]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_56FAM
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[36FAM]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_36FAM
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[5HEX]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_5HEX
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[5TMR]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_5TMR
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[3BHQ1]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_3BHQ1
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[3BHQ2]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_3BHQ2
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[5NH2]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_5NH2
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[3NH2]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_3NH2
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[5PO4]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_5PO4
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[3PO4]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_3PO4
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[3BioTEG]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_3BioTEG
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[C12]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_C12
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[NHSdT]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_NHSdT
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[5Mal]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_5Mal
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[5thio]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_5thio
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[3thio]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_3thio
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[3azide]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_3azide
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[3alkine]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_3alkine
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[5CholTEG]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_5CholTEG
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[3CholTEG]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_3CholTEG
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[5C10]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_5C10
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[5Alk]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_5Alk
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[GC]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_GC
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[GT]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_GT
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[AT]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_AT
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[TG]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_TG
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[AC]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_AC
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[CC]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_CC
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[AA]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_AA
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[TC]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_TC
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[TT]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_TT
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[CG]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_CG
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[GG]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_GG
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[AG]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_AG
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[GA]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_GA
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[CA]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_CA
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[CT]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_CT
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[TA]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_TA
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[AAA]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_AAA
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[AAC]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_AAC
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[ACT]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_ACT
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[ATC]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_ATC
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[ATG]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_ATG
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[CAG]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_CAG
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[AGA]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_AGA
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[CAT]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_CAT
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[CCG]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_CCG
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[CGT]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_CGT
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[CTG]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_CTG
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[GAA]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_GAA
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[GAC]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_GAC
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[GCT]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_GCT
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[GGT]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_GGT
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[GTT]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_GTT
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[TAC]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_TAC
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[TCT]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_TCT
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[TGC]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_TGC
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[TGG]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_TGG
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[TTC]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_TTC
  , forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[TTT]" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Modification
Mod_TTT
  , Parser Modification
unknownP
  ]

unknownP :: Parser Modification
unknownP :: Parser Modification
unknownP = do
  String
res <- forall (m :: * -> *) open close a.
Applicative m =>
m open -> m close -> m a -> m a
between (Text -> Parser Text
symbol Text
"[") (Text -> Parser Text
symbol Text
"]")
    (forall a. Parser a -> Parser a
lexeme (forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
alphaNumChar forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
choice (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char
'+', Char
'-', Char
'*', Char
'_'])) forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> String -> m a
<?> String
"modification name"))
  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ String -> Modification
Unknown (String
"[" forall a. Semigroup a => a -> a -> a
<> String
res forall a. Semigroup a => a -> a -> a
<> String
"]")