module Bio.Uniprot.Type where

import           Data.Text    (Text)
import           GHC.Generics (Generic)

-- | Which taxonomic 'kingdom' an
--   organism belongs to.
data Kingdom
  = Archea    -- ^ 'A' for archaea (=archaebacteria)
  | Bacteria  -- ^ 'B' for bacteria (=prokaryota or eubacteria)
  | Eukaryota -- ^ 'E' for eukaryota (=eukarya)
  | Virus     -- ^ 'V' for viruses and phages (=viridae)
  | Other     -- ^ 'O' for others (such as artificial sequences)
  deriving ((forall x. Kingdom -> Rep Kingdom x)
-> (forall x. Rep Kingdom x -> Kingdom) -> Generic Kingdom
forall x. Rep Kingdom x -> Kingdom
forall x. Kingdom -> Rep Kingdom x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Kingdom x -> Kingdom
$cfrom :: forall x. Kingdom -> Rep Kingdom x
Generic, Int -> Kingdom -> ShowS
[Kingdom] -> ShowS
Kingdom -> String
(Int -> Kingdom -> ShowS)
-> (Kingdom -> String) -> ([Kingdom] -> ShowS) -> Show Kingdom
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Kingdom] -> ShowS
$cshowList :: [Kingdom] -> ShowS
show :: Kingdom -> String
$cshow :: Kingdom -> String
showsPrec :: Int -> Kingdom -> ShowS
$cshowsPrec :: Int -> Kingdom -> ShowS
Show, Kingdom -> Kingdom -> Bool
(Kingdom -> Kingdom -> Bool)
-> (Kingdom -> Kingdom -> Bool) -> Eq Kingdom
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Kingdom -> Kingdom -> Bool
$c/= :: Kingdom -> Kingdom -> Bool
== :: Kingdom -> Kingdom -> Bool
$c== :: Kingdom -> Kingdom -> Bool
Eq, Eq Kingdom
Eq Kingdom
-> (Kingdom -> Kingdom -> Ordering)
-> (Kingdom -> Kingdom -> Bool)
-> (Kingdom -> Kingdom -> Bool)
-> (Kingdom -> Kingdom -> Bool)
-> (Kingdom -> Kingdom -> Bool)
-> (Kingdom -> Kingdom -> Kingdom)
-> (Kingdom -> Kingdom -> Kingdom)
-> Ord Kingdom
Kingdom -> Kingdom -> Bool
Kingdom -> Kingdom -> Ordering
Kingdom -> Kingdom -> Kingdom
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 :: Kingdom -> Kingdom -> Kingdom
$cmin :: Kingdom -> Kingdom -> Kingdom
max :: Kingdom -> Kingdom -> Kingdom
$cmax :: Kingdom -> Kingdom -> Kingdom
>= :: Kingdom -> Kingdom -> Bool
$c>= :: Kingdom -> Kingdom -> Bool
> :: Kingdom -> Kingdom -> Bool
$c> :: Kingdom -> Kingdom -> Bool
<= :: Kingdom -> Kingdom -> Bool
$c<= :: Kingdom -> Kingdom -> Bool
< :: Kingdom -> Kingdom -> Bool
$c< :: Kingdom -> Kingdom -> Bool
compare :: Kingdom -> Kingdom -> Ordering
$ccompare :: Kingdom -> Kingdom -> Ordering
$cp1Ord :: Eq Kingdom
Ord, Kingdom
Kingdom -> Kingdom -> Bounded Kingdom
forall a. a -> a -> Bounded a
maxBound :: Kingdom
$cmaxBound :: Kingdom
minBound :: Kingdom
$cminBound :: Kingdom
Bounded, Int -> Kingdom
Kingdom -> Int
Kingdom -> [Kingdom]
Kingdom -> Kingdom
Kingdom -> Kingdom -> [Kingdom]
Kingdom -> Kingdom -> Kingdom -> [Kingdom]
(Kingdom -> Kingdom)
-> (Kingdom -> Kingdom)
-> (Int -> Kingdom)
-> (Kingdom -> Int)
-> (Kingdom -> [Kingdom])
-> (Kingdom -> Kingdom -> [Kingdom])
-> (Kingdom -> Kingdom -> [Kingdom])
-> (Kingdom -> Kingdom -> Kingdom -> [Kingdom])
-> Enum Kingdom
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Kingdom -> Kingdom -> Kingdom -> [Kingdom]
$cenumFromThenTo :: Kingdom -> Kingdom -> Kingdom -> [Kingdom]
enumFromTo :: Kingdom -> Kingdom -> [Kingdom]
$cenumFromTo :: Kingdom -> Kingdom -> [Kingdom]
enumFromThen :: Kingdom -> Kingdom -> [Kingdom]
$cenumFromThen :: Kingdom -> Kingdom -> [Kingdom]
enumFrom :: Kingdom -> [Kingdom]
$cenumFrom :: Kingdom -> [Kingdom]
fromEnum :: Kingdom -> Int
$cfromEnum :: Kingdom -> Int
toEnum :: Int -> Kingdom
$ctoEnum :: Int -> Kingdom
pred :: Kingdom -> Kingdom
$cpred :: Kingdom -> Kingdom
succ :: Kingdom -> Kingdom
$csucc :: Kingdom -> Kingdom
Enum)

-- | Controlled vocabulary of species
data Organism = Organism
  { Organism -> Text
code         :: Text       -- ^ Code of organism (up to 5 symbols)
  , Organism -> Kingdom
kingdom      :: Kingdom    -- ^ Kingdom of organism
  , Organism -> Text
officialName :: Text       -- ^ Official (scientific) name
  , Organism -> Maybe Text
commonName   :: Maybe Text -- ^ Common name
  , Organism -> Maybe Text
synonym      :: Maybe Text -- ^ Synonym name
  } deriving ((forall x. Organism -> Rep Organism x)
-> (forall x. Rep Organism x -> Organism) -> Generic Organism
forall x. Rep Organism x -> Organism
forall x. Organism -> Rep Organism x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Organism x -> Organism
$cfrom :: forall x. Organism -> Rep Organism x
Generic, Int -> Organism -> ShowS
[Organism] -> ShowS
Organism -> String
(Int -> Organism -> ShowS)
-> (Organism -> String) -> ([Organism] -> ShowS) -> Show Organism
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Organism] -> ShowS
$cshowList :: [Organism] -> ShowS
show :: Organism -> String
$cshow :: Organism -> String
showsPrec :: Int -> Organism -> ShowS
$cshowsPrec :: Int -> Organism -> ShowS
Show, Organism -> Organism -> Bool
(Organism -> Organism -> Bool)
-> (Organism -> Organism -> Bool) -> Eq Organism
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Organism -> Organism -> Bool
$c/= :: Organism -> Organism -> Bool
== :: Organism -> Organism -> Bool
$c== :: Organism -> Organism -> Bool
Eq, Eq Organism
Eq Organism
-> (Organism -> Organism -> Ordering)
-> (Organism -> Organism -> Bool)
-> (Organism -> Organism -> Bool)
-> (Organism -> Organism -> Bool)
-> (Organism -> Organism -> Bool)
-> (Organism -> Organism -> Organism)
-> (Organism -> Organism -> Organism)
-> Ord Organism
Organism -> Organism -> Bool
Organism -> Organism -> Ordering
Organism -> Organism -> Organism
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 :: Organism -> Organism -> Organism
$cmin :: Organism -> Organism -> Organism
max :: Organism -> Organism -> Organism
$cmax :: Organism -> Organism -> Organism
>= :: Organism -> Organism -> Bool
$c>= :: Organism -> Organism -> Bool
> :: Organism -> Organism -> Bool
$c> :: Organism -> Organism -> Bool
<= :: Organism -> Organism -> Bool
$c<= :: Organism -> Organism -> Bool
< :: Organism -> Organism -> Bool
$c< :: Organism -> Organism -> Bool
compare :: Organism -> Organism -> Ordering
$ccompare :: Organism -> Organism -> Ordering
$cp1Ord :: Eq Organism
Ord)

-- | To distinguish the fully annotated entries in the Swiss-Prot
--   section of the UniProt Knowledgebase from the computer-annotated
--   entries in the TrEMBL section, the 'status' of each entry is
--   indicated in the first (ID) line of each entry
data Status
  = Reviewed   -- ^ Entries that have been manually reviewed and annotated by UniProtKB curators
  | Unreviewed -- ^ Computer-annotated entries that have not been reviewed by UniProtKB curators
  deriving ((forall x. Status -> Rep Status x)
-> (forall x. Rep Status x -> Status) -> Generic Status
forall x. Rep Status x -> Status
forall x. Status -> Rep Status x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Status x -> Status
$cfrom :: forall x. Status -> Rep Status x
Generic, Int -> Status -> ShowS
[Status] -> ShowS
Status -> String
(Int -> Status -> ShowS)
-> (Status -> String) -> ([Status] -> ShowS) -> Show Status
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Status] -> ShowS
$cshowList :: [Status] -> ShowS
show :: Status -> String
$cshow :: Status -> String
showsPrec :: Int -> Status -> ShowS
$cshowsPrec :: Int -> Status -> ShowS
Show, Status -> Status -> Bool
(Status -> Status -> Bool)
-> (Status -> Status -> Bool) -> Eq Status
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Status -> Status -> Bool
$c/= :: Status -> Status -> Bool
== :: Status -> Status -> Bool
$c== :: Status -> Status -> Bool
Eq, Eq Status
Eq Status
-> (Status -> Status -> Ordering)
-> (Status -> Status -> Bool)
-> (Status -> Status -> Bool)
-> (Status -> Status -> Bool)
-> (Status -> Status -> Bool)
-> (Status -> Status -> Status)
-> (Status -> Status -> Status)
-> Ord Status
Status -> Status -> Bool
Status -> Status -> Ordering
Status -> Status -> Status
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 :: Status -> Status -> Status
$cmin :: Status -> Status -> Status
max :: Status -> Status -> Status
$cmax :: Status -> Status -> Status
>= :: Status -> Status -> Bool
$c>= :: Status -> Status -> Bool
> :: Status -> Status -> Bool
$c> :: Status -> Status -> Bool
<= :: Status -> Status -> Bool
$c<= :: Status -> Status -> Bool
< :: Status -> Status -> Bool
$c< :: Status -> Status -> Bool
compare :: Status -> Status -> Ordering
$ccompare :: Status -> Status -> Ordering
$cp1Ord :: Eq Status
Ord, Status
Status -> Status -> Bounded Status
forall a. a -> a -> Bounded a
maxBound :: Status
$cmaxBound :: Status
minBound :: Status
$cminBound :: Status
Bounded, Int -> Status
Status -> Int
Status -> [Status]
Status -> Status
Status -> Status -> [Status]
Status -> Status -> Status -> [Status]
(Status -> Status)
-> (Status -> Status)
-> (Int -> Status)
-> (Status -> Int)
-> (Status -> [Status])
-> (Status -> Status -> [Status])
-> (Status -> Status -> [Status])
-> (Status -> Status -> Status -> [Status])
-> Enum Status
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Status -> Status -> Status -> [Status]
$cenumFromThenTo :: Status -> Status -> Status -> [Status]
enumFromTo :: Status -> Status -> [Status]
$cenumFromTo :: Status -> Status -> [Status]
enumFromThen :: Status -> Status -> [Status]
$cenumFromThen :: Status -> Status -> [Status]
enumFrom :: Status -> [Status]
$cenumFrom :: Status -> [Status]
fromEnum :: Status -> Int
$cfromEnum :: Status -> Int
toEnum :: Int -> Status
$ctoEnum :: Int -> Status
pred :: Status -> Status
$cpred :: Status -> Status
succ :: Status -> Status
$csucc :: Status -> Status
Enum)

-- | IDentification
data ID = ID
  { ID -> Text
entryName :: Text   -- ^ This name is a useful means of identifying a sequence, but it is not a stable identifier as is the accession number.
  , ID -> Status
status    :: Status -- ^ The status of the entry
  , ID -> Int
seqLength :: Int    -- ^ The length of the molecule, which is the total number of amino acids in the sequence. This number includes the positions reported to be present but which have not been determined (coded as 'X').
  } deriving ((forall x. ID -> Rep ID x)
-> (forall x. Rep ID x -> ID) -> Generic ID
forall x. Rep ID x -> ID
forall x. ID -> Rep ID x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ID x -> ID
$cfrom :: forall x. ID -> Rep ID x
Generic, Int -> ID -> ShowS
[ID] -> ShowS
ID -> String
(Int -> ID -> ShowS)
-> (ID -> String) -> ([ID] -> ShowS) -> Show ID
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ID] -> ShowS
$cshowList :: [ID] -> ShowS
show :: ID -> String
$cshow :: ID -> String
showsPrec :: Int -> ID -> ShowS
$cshowsPrec :: Int -> ID -> ShowS
Show, ID -> ID -> Bool
(ID -> ID -> Bool) -> (ID -> ID -> Bool) -> Eq ID
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ID -> ID -> Bool
$c/= :: ID -> ID -> Bool
== :: ID -> ID -> Bool
$c== :: ID -> ID -> Bool
Eq, Eq ID
Eq ID
-> (ID -> ID -> Ordering)
-> (ID -> ID -> Bool)
-> (ID -> ID -> Bool)
-> (ID -> ID -> Bool)
-> (ID -> ID -> Bool)
-> (ID -> ID -> ID)
-> (ID -> ID -> ID)
-> Ord ID
ID -> ID -> Bool
ID -> ID -> Ordering
ID -> ID -> ID
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 :: ID -> ID -> ID
$cmin :: ID -> ID -> ID
max :: ID -> ID -> ID
$cmax :: ID -> ID -> ID
>= :: ID -> ID -> Bool
$c>= :: ID -> ID -> Bool
> :: ID -> ID -> Bool
$c> :: ID -> ID -> Bool
<= :: ID -> ID -> Bool
$c<= :: ID -> ID -> Bool
< :: ID -> ID -> Bool
$c< :: ID -> ID -> Bool
compare :: ID -> ID -> Ordering
$ccompare :: ID -> ID -> Ordering
$cp1Ord :: Eq ID
Ord)

-- | ACcession numbers.
--   The purpose of accession numbers is to provide a stable way of
--   identifying entries from release to release. It is sometimes
--   necessary for reasons of consistency to change the names of the
--   entries, for example, to ensure that related entries have similar
--   names. However, an accession number is always conserved, and
--   therefore allows unambiguous citation of entries.
--   Researchers who wish to cite entries in their publications should
--   always cite the first accession number. This is commonly referred
--   to as the 'primary accession number'. 'Secondary accession numbers'
--   are sorted alphanumerically.
newtype AC = AC
  { AC -> [Text]
accessionNumbers :: [Text]
  } deriving ((forall x. AC -> Rep AC x)
-> (forall x. Rep AC x -> AC) -> Generic AC
forall x. Rep AC x -> AC
forall x. AC -> Rep AC x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep AC x -> AC
$cfrom :: forall x. AC -> Rep AC x
Generic, Int -> AC -> ShowS
[AC] -> ShowS
AC -> String
(Int -> AC -> ShowS)
-> (AC -> String) -> ([AC] -> ShowS) -> Show AC
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AC] -> ShowS
$cshowList :: [AC] -> ShowS
show :: AC -> String
$cshow :: AC -> String
showsPrec :: Int -> AC -> ShowS
$cshowsPrec :: Int -> AC -> ShowS
Show, AC -> AC -> Bool
(AC -> AC -> Bool) -> (AC -> AC -> Bool) -> Eq AC
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AC -> AC -> Bool
$c/= :: AC -> AC -> Bool
== :: AC -> AC -> Bool
$c== :: AC -> AC -> Bool
Eq, Eq AC
Eq AC
-> (AC -> AC -> Ordering)
-> (AC -> AC -> Bool)
-> (AC -> AC -> Bool)
-> (AC -> AC -> Bool)
-> (AC -> AC -> Bool)
-> (AC -> AC -> AC)
-> (AC -> AC -> AC)
-> Ord AC
AC -> AC -> Bool
AC -> AC -> Ordering
AC -> AC -> AC
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 :: AC -> AC -> AC
$cmin :: AC -> AC -> AC
max :: AC -> AC -> AC
$cmax :: AC -> AC -> AC
>= :: AC -> AC -> Bool
$c>= :: AC -> AC -> Bool
> :: AC -> AC -> Bool
$c> :: AC -> AC -> Bool
<= :: AC -> AC -> Bool
$c<= :: AC -> AC -> Bool
< :: AC -> AC -> Bool
$c< :: AC -> AC -> Bool
compare :: AC -> AC -> Ordering
$ccompare :: AC -> AC -> Ordering
$cp1Ord :: Eq AC
Ord)

-- | DaTe: the date of creation and last modification of the database entry.
data DT = DT
  { DT -> Text
dbIntegrationDate :: Text -- ^ Indicates when the entry first appeared in the database.
  , DT -> Text
dbName            :: Text -- ^ Indicates in which section of UniProtKB, Swiss-Prot or TrEMBL, the entry can be found.
  , DT -> Text
seqVersionDate    :: Text -- ^ Indicates when the sequence data was last modified.
  , DT -> Int
seqVersion        :: Int  -- ^ The sequence version number of an entry is incremented by one when the amino acid sequence shown in the sequence record is modified.
  , DT -> Text
entryVersionDate  :: Text -- ^ Indicates when data other than the sequence was last modified.
  , DT -> Int
entryVersion      :: Int  -- ^ The entry version number is incremented by one whenever any data in the flat file representation of the entry is modified.
  } deriving ((forall x. DT -> Rep DT x)
-> (forall x. Rep DT x -> DT) -> Generic DT
forall x. Rep DT x -> DT
forall x. DT -> Rep DT x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DT x -> DT
$cfrom :: forall x. DT -> Rep DT x
Generic, Int -> DT -> ShowS
[DT] -> ShowS
DT -> String
(Int -> DT -> ShowS)
-> (DT -> String) -> ([DT] -> ShowS) -> Show DT
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DT] -> ShowS
$cshowList :: [DT] -> ShowS
show :: DT -> String
$cshow :: DT -> String
showsPrec :: Int -> DT -> ShowS
$cshowsPrec :: Int -> DT -> ShowS
Show, DT -> DT -> Bool
(DT -> DT -> Bool) -> (DT -> DT -> Bool) -> Eq DT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DT -> DT -> Bool
$c/= :: DT -> DT -> Bool
== :: DT -> DT -> Bool
$c== :: DT -> DT -> Bool
Eq, Eq DT
Eq DT
-> (DT -> DT -> Ordering)
-> (DT -> DT -> Bool)
-> (DT -> DT -> Bool)
-> (DT -> DT -> Bool)
-> (DT -> DT -> Bool)
-> (DT -> DT -> DT)
-> (DT -> DT -> DT)
-> Ord DT
DT -> DT -> Bool
DT -> DT -> Ordering
DT -> DT -> DT
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 :: DT -> DT -> DT
$cmin :: DT -> DT -> DT
max :: DT -> DT -> DT
$cmax :: DT -> DT -> DT
>= :: DT -> DT -> Bool
$c>= :: DT -> DT -> Bool
> :: DT -> DT -> Bool
$c> :: DT -> DT -> Bool
<= :: DT -> DT -> Bool
$c<= :: DT -> DT -> Bool
< :: DT -> DT -> Bool
$c< :: DT -> DT -> Bool
compare :: DT -> DT -> Ordering
$ccompare :: DT -> DT -> Ordering
$cp1Ord :: Eq DT
Ord)

data Name = Name
  { Name -> Text
fullName  :: Text   -- ^ The full name.
  , Name -> [Text]
shortName :: [Text] -- ^ A set of abbreviations of the full name or acronyms.
  , Name -> [Text]
ecNumber  :: [Text] -- ^ A set of Enzyme Commission numbers.
  } deriving ((forall x. Name -> Rep Name x)
-> (forall x. Rep Name x -> Name) -> Generic Name
forall x. Rep Name x -> Name
forall x. Name -> Rep Name x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Name x -> Name
$cfrom :: forall x. Name -> Rep Name x
Generic, Int -> Name -> ShowS
[Name] -> ShowS
Name -> String
(Int -> Name -> ShowS)
-> (Name -> String) -> ([Name] -> ShowS) -> Show Name
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Name] -> ShowS
$cshowList :: [Name] -> ShowS
show :: Name -> String
$cshow :: Name -> String
showsPrec :: Int -> Name -> ShowS
$cshowsPrec :: Int -> Name -> ShowS
Show, Name -> Name -> Bool
(Name -> Name -> Bool) -> (Name -> Name -> Bool) -> Eq Name
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c== :: Name -> Name -> Bool
Eq, Eq Name
Eq Name
-> (Name -> Name -> Ordering)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Name)
-> (Name -> Name -> Name)
-> Ord Name
Name -> Name -> Bool
Name -> Name -> Ordering
Name -> Name -> Name
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 :: Name -> Name -> Name
$cmin :: Name -> Name -> Name
max :: Name -> Name -> Name
$cmax :: Name -> Name -> Name
>= :: Name -> Name -> Bool
$c>= :: Name -> Name -> Bool
> :: Name -> Name -> Bool
$c> :: Name -> Name -> Bool
<= :: Name -> Name -> Bool
$c<= :: Name -> Name -> Bool
< :: Name -> Name -> Bool
$c< :: Name -> Name -> Bool
compare :: Name -> Name -> Ordering
$ccompare :: Name -> Name -> Ordering
$cp1Ord :: Eq Name
Ord)

data AltName = Simple Name
             | Allergen Text
             | Biotech Text
             | CDAntigen Text
             | INN Text
  deriving ((forall x. AltName -> Rep AltName x)
-> (forall x. Rep AltName x -> AltName) -> Generic AltName
forall x. Rep AltName x -> AltName
forall x. AltName -> Rep AltName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep AltName x -> AltName
$cfrom :: forall x. AltName -> Rep AltName x
Generic, Int -> AltName -> ShowS
[AltName] -> ShowS
AltName -> String
(Int -> AltName -> ShowS)
-> (AltName -> String) -> ([AltName] -> ShowS) -> Show AltName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AltName] -> ShowS
$cshowList :: [AltName] -> ShowS
show :: AltName -> String
$cshow :: AltName -> String
showsPrec :: Int -> AltName -> ShowS
$cshowsPrec :: Int -> AltName -> ShowS
Show, AltName -> AltName -> Bool
(AltName -> AltName -> Bool)
-> (AltName -> AltName -> Bool) -> Eq AltName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AltName -> AltName -> Bool
$c/= :: AltName -> AltName -> Bool
== :: AltName -> AltName -> Bool
$c== :: AltName -> AltName -> Bool
Eq, Eq AltName
Eq AltName
-> (AltName -> AltName -> Ordering)
-> (AltName -> AltName -> Bool)
-> (AltName -> AltName -> Bool)
-> (AltName -> AltName -> Bool)
-> (AltName -> AltName -> Bool)
-> (AltName -> AltName -> AltName)
-> (AltName -> AltName -> AltName)
-> Ord AltName
AltName -> AltName -> Bool
AltName -> AltName -> Ordering
AltName -> AltName -> AltName
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 :: AltName -> AltName -> AltName
$cmin :: AltName -> AltName -> AltName
max :: AltName -> AltName -> AltName
$cmax :: AltName -> AltName -> AltName
>= :: AltName -> AltName -> Bool
$c>= :: AltName -> AltName -> Bool
> :: AltName -> AltName -> Bool
$c> :: AltName -> AltName -> Bool
<= :: AltName -> AltName -> Bool
$c<= :: AltName -> AltName -> Bool
< :: AltName -> AltName -> Bool
$c< :: AltName -> AltName -> Bool
compare :: AltName -> AltName -> Ordering
$ccompare :: AltName -> AltName -> Ordering
$cp1Ord :: Eq AltName
Ord)

data Flag
  = Fragment  -- ^ The complete sequence is not determined.
  | Fragments -- ^ The complete sequence is not determined.
  | Precursor -- ^ The sequence displayed does not correspond to the mature form of the protein.
  deriving ((forall x. Flag -> Rep Flag x)
-> (forall x. Rep Flag x -> Flag) -> Generic Flag
forall x. Rep Flag x -> Flag
forall x. Flag -> Rep Flag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Flag x -> Flag
$cfrom :: forall x. Flag -> Rep Flag x
Generic, Int -> Flag -> ShowS
[Flag] -> ShowS
Flag -> String
(Int -> Flag -> ShowS)
-> (Flag -> String) -> ([Flag] -> ShowS) -> Show Flag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Flag] -> ShowS
$cshowList :: [Flag] -> ShowS
show :: Flag -> String
$cshow :: Flag -> String
showsPrec :: Int -> Flag -> ShowS
$cshowsPrec :: Int -> Flag -> ShowS
Show, ReadPrec [Flag]
ReadPrec Flag
Int -> ReadS Flag
ReadS [Flag]
(Int -> ReadS Flag)
-> ReadS [Flag] -> ReadPrec Flag -> ReadPrec [Flag] -> Read Flag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Flag]
$creadListPrec :: ReadPrec [Flag]
readPrec :: ReadPrec Flag
$creadPrec :: ReadPrec Flag
readList :: ReadS [Flag]
$creadList :: ReadS [Flag]
readsPrec :: Int -> ReadS Flag
$creadsPrec :: Int -> ReadS Flag
Read, Flag -> Flag -> Bool
(Flag -> Flag -> Bool) -> (Flag -> Flag -> Bool) -> Eq Flag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Flag -> Flag -> Bool
$c/= :: Flag -> Flag -> Bool
== :: Flag -> Flag -> Bool
$c== :: Flag -> Flag -> Bool
Eq, Eq Flag
Eq Flag
-> (Flag -> Flag -> Ordering)
-> (Flag -> Flag -> Bool)
-> (Flag -> Flag -> Bool)
-> (Flag -> Flag -> Bool)
-> (Flag -> Flag -> Bool)
-> (Flag -> Flag -> Flag)
-> (Flag -> Flag -> Flag)
-> Ord Flag
Flag -> Flag -> Bool
Flag -> Flag -> Ordering
Flag -> Flag -> Flag
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 :: Flag -> Flag -> Flag
$cmin :: Flag -> Flag -> Flag
max :: Flag -> Flag -> Flag
$cmax :: Flag -> Flag -> Flag
>= :: Flag -> Flag -> Bool
$c>= :: Flag -> Flag -> Bool
> :: Flag -> Flag -> Bool
$c> :: Flag -> Flag -> Bool
<= :: Flag -> Flag -> Bool
$c<= :: Flag -> Flag -> Bool
< :: Flag -> Flag -> Bool
$c< :: Flag -> Flag -> Bool
compare :: Flag -> Flag -> Ordering
$ccompare :: Flag -> Flag -> Ordering
$cp1Ord :: Eq Flag
Ord, Flag
Flag -> Flag -> Bounded Flag
forall a. a -> a -> Bounded a
maxBound :: Flag
$cmaxBound :: Flag
minBound :: Flag
$cminBound :: Flag
Bounded, Int -> Flag
Flag -> Int
Flag -> [Flag]
Flag -> Flag
Flag -> Flag -> [Flag]
Flag -> Flag -> Flag -> [Flag]
(Flag -> Flag)
-> (Flag -> Flag)
-> (Int -> Flag)
-> (Flag -> Int)
-> (Flag -> [Flag])
-> (Flag -> Flag -> [Flag])
-> (Flag -> Flag -> [Flag])
-> (Flag -> Flag -> Flag -> [Flag])
-> Enum Flag
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Flag -> Flag -> Flag -> [Flag]
$cenumFromThenTo :: Flag -> Flag -> Flag -> [Flag]
enumFromTo :: Flag -> Flag -> [Flag]
$cenumFromTo :: Flag -> Flag -> [Flag]
enumFromThen :: Flag -> Flag -> [Flag]
$cenumFromThen :: Flag -> Flag -> [Flag]
enumFrom :: Flag -> [Flag]
$cenumFrom :: Flag -> [Flag]
fromEnum :: Flag -> Int
$cfromEnum :: Flag -> Int
toEnum :: Int -> Flag
$ctoEnum :: Int -> Flag
pred :: Flag -> Flag
$cpred :: Flag -> Flag
succ :: Flag -> Flag
$csucc :: Flag -> Flag
Enum)

-- | DEscription - general descriptive information about the sequence stored.
data DE = DE
  { DE -> Maybe Name
recName  :: Maybe Name -- ^ The name recommended by the UniProt consortium.
  , DE -> [AltName]
altNames :: [AltName]  -- ^ A synonym of the recommended name.
  , DE -> [Name]
subNames :: [Name]     -- ^ A name provided by the submitter of the underlying nucleotide sequence.
  , DE -> [DE]
includes :: [DE]       -- ^ A protein is known to include multiple functional domains each of which is described by a different name.
  , DE -> [DE]
contains :: [DE]       -- ^ The functional domains of an enzyme are cleaved, but the catalytic activity can only be observed, when the individual chains reorganize in a complex.
  , DE -> [Flag]
flags    :: [Flag]     -- ^ Flags whether the entire is a precursor or/and a fragment.
  } deriving ((forall x. DE -> Rep DE x)
-> (forall x. Rep DE x -> DE) -> Generic DE
forall x. Rep DE x -> DE
forall x. DE -> Rep DE x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DE x -> DE
$cfrom :: forall x. DE -> Rep DE x
Generic, Int -> DE -> ShowS
[DE] -> ShowS
DE -> String
(Int -> DE -> ShowS)
-> (DE -> String) -> ([DE] -> ShowS) -> Show DE
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DE] -> ShowS
$cshowList :: [DE] -> ShowS
show :: DE -> String
$cshow :: DE -> String
showsPrec :: Int -> DE -> ShowS
$cshowsPrec :: Int -> DE -> ShowS
Show, DE -> DE -> Bool
(DE -> DE -> Bool) -> (DE -> DE -> Bool) -> Eq DE
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DE -> DE -> Bool
$c/= :: DE -> DE -> Bool
== :: DE -> DE -> Bool
$c== :: DE -> DE -> Bool
Eq, Eq DE
Eq DE
-> (DE -> DE -> Ordering)
-> (DE -> DE -> Bool)
-> (DE -> DE -> Bool)
-> (DE -> DE -> Bool)
-> (DE -> DE -> Bool)
-> (DE -> DE -> DE)
-> (DE -> DE -> DE)
-> Ord DE
DE -> DE -> Bool
DE -> DE -> Ordering
DE -> DE -> DE
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 :: DE -> DE -> DE
$cmin :: DE -> DE -> DE
max :: DE -> DE -> DE
$cmax :: DE -> DE -> DE
>= :: DE -> DE -> Bool
$c>= :: DE -> DE -> Bool
> :: DE -> DE -> Bool
$c> :: DE -> DE -> Bool
<= :: DE -> DE -> Bool
$c<= :: DE -> DE -> Bool
< :: DE -> DE -> Bool
$c< :: DE -> DE -> Bool
compare :: DE -> DE -> Ordering
$ccompare :: DE -> DE -> Ordering
$cp1Ord :: Eq DE
Ord)

-- | Gene Name - the name(s) of the gene(s) that code for the stored protein sequence.
data GN = GN
  { GN -> Maybe Text
geneName          :: Maybe Text -- ^ The name used to represent a gene.
  , GN -> [Text]
synonyms          :: [Text]     -- ^ Other (unofficial) names of a gene.
  , GN -> [Text]
orderedLocusNames :: [Text]     -- ^ A name used to represent an ORF in a completely sequenced genome or chromosome.
  , GN -> [Text]
orfNames          :: [Text]     -- ^ A name temporarily attributed by a sequencing project to an open reading frame.
  } deriving ((forall x. GN -> Rep GN x)
-> (forall x. Rep GN x -> GN) -> Generic GN
forall x. Rep GN x -> GN
forall x. GN -> Rep GN x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GN x -> GN
$cfrom :: forall x. GN -> Rep GN x
Generic, Int -> GN -> ShowS
[GN] -> ShowS
GN -> String
(Int -> GN -> ShowS)
-> (GN -> String) -> ([GN] -> ShowS) -> Show GN
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GN] -> ShowS
$cshowList :: [GN] -> ShowS
show :: GN -> String
$cshow :: GN -> String
showsPrec :: Int -> GN -> ShowS
$cshowsPrec :: Int -> GN -> ShowS
Show, GN -> GN -> Bool
(GN -> GN -> Bool) -> (GN -> GN -> Bool) -> Eq GN
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GN -> GN -> Bool
$c/= :: GN -> GN -> Bool
== :: GN -> GN -> Bool
$c== :: GN -> GN -> Bool
Eq, Eq GN
Eq GN
-> (GN -> GN -> Ordering)
-> (GN -> GN -> Bool)
-> (GN -> GN -> Bool)
-> (GN -> GN -> Bool)
-> (GN -> GN -> Bool)
-> (GN -> GN -> GN)
-> (GN -> GN -> GN)
-> Ord GN
GN -> GN -> Bool
GN -> GN -> Ordering
GN -> GN -> GN
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 :: GN -> GN -> GN
$cmin :: GN -> GN -> GN
max :: GN -> GN -> GN
$cmax :: GN -> GN -> GN
>= :: GN -> GN -> Bool
$c>= :: GN -> GN -> Bool
> :: GN -> GN -> Bool
$c> :: GN -> GN -> Bool
<= :: GN -> GN -> Bool
$c<= :: GN -> GN -> Bool
< :: GN -> GN -> Bool
$c< :: GN -> GN -> Bool
compare :: GN -> GN -> Ordering
$ccompare :: GN -> GN -> Ordering
$cp1Ord :: Eq GN
Ord)

-- | Organism Species - the organism which was the source of the stored sequence.
newtype OS = OS
  { OS -> Text
specie :: Text
  } deriving ((forall x. OS -> Rep OS x)
-> (forall x. Rep OS x -> OS) -> Generic OS
forall x. Rep OS x -> OS
forall x. OS -> Rep OS x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OS x -> OS
$cfrom :: forall x. OS -> Rep OS x
Generic, Int -> OS -> ShowS
[OS] -> ShowS
OS -> String
(Int -> OS -> ShowS)
-> (OS -> String) -> ([OS] -> ShowS) -> Show OS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OS] -> ShowS
$cshowList :: [OS] -> ShowS
show :: OS -> String
$cshow :: OS -> String
showsPrec :: Int -> OS -> ShowS
$cshowsPrec :: Int -> OS -> ShowS
Show, OS -> OS -> Bool
(OS -> OS -> Bool) -> (OS -> OS -> Bool) -> Eq OS
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OS -> OS -> Bool
$c/= :: OS -> OS -> Bool
== :: OS -> OS -> Bool
$c== :: OS -> OS -> Bool
Eq, Eq OS
Eq OS
-> (OS -> OS -> Ordering)
-> (OS -> OS -> Bool)
-> (OS -> OS -> Bool)
-> (OS -> OS -> Bool)
-> (OS -> OS -> Bool)
-> (OS -> OS -> OS)
-> (OS -> OS -> OS)
-> Ord OS
OS -> OS -> Bool
OS -> OS -> Ordering
OS -> OS -> OS
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 :: OS -> OS -> OS
$cmin :: OS -> OS -> OS
max :: OS -> OS -> OS
$cmax :: OS -> OS -> OS
>= :: OS -> OS -> Bool
$c>= :: OS -> OS -> Bool
> :: OS -> OS -> Bool
$c> :: OS -> OS -> Bool
<= :: OS -> OS -> Bool
$c<= :: OS -> OS -> Bool
< :: OS -> OS -> Bool
$c< :: OS -> OS -> Bool
compare :: OS -> OS -> Ordering
$ccompare :: OS -> OS -> Ordering
$cp1Ord :: Eq OS
Ord)

-- | A enum of possible plastid types, based on either taxonomic
--   lineage or photosynthetic capacity.
data Plastid = PlastidSimple                  -- ^ The term Plastid is used when the capacities of the organism are unclear; for example in the parasitic plants of the Cuscuta lineage, where sometimes young tissue is photosynthetic.
             | PlastidApicoplast              -- ^ Apicoplasts are the plastids found in Apicocomplexa parasites such as Eimeria, Plasmodium and Toxoplasma; they are not photosynthetic.
             | PlastidChloroplast             -- ^ Chloroplasts are the plastids found in all land plants and algae with the exception of the glaucocystophyte algae (see below). Chloroplasts in green tissue are photosynthetic; in other tissues they may not be photosynthetic and then may also have secondary information relating to subcellular location (e.g. amyloplasts, chromoplasts).
             | PlastidOrganellarChromatophore -- ^ Chloroplasts are the plastids found in all land plants and algae with the exception of the glaucocystophyte algae (see below). Chloroplasts in green tissue are photosynthetic; in other tissues they may not be photosynthetic and then may also have secondary information relating to subcellular location (e.g. amyloplasts, chromoplasts).
             | PlastidCyanelle                -- ^ Cyanelles are the plastids found in the glaucocystophyte algae. They are also photosynthetic but their plastid has a vestigial cell wall between the 2 envelope membranes.
             | PlastidNonPhotosynthetic       -- ^ Non-photosynthetic plastid is used when the plastid in question derives from a photosynthetic lineage but the plastid in question is missing essential genes. Some examples are Aneura mirabilis, Epifagus virginiana, Helicosporidium (a liverwort, higher plant and green alga respectively).
  deriving ((forall x. Plastid -> Rep Plastid x)
-> (forall x. Rep Plastid x -> Plastid) -> Generic Plastid
forall x. Rep Plastid x -> Plastid
forall x. Plastid -> Rep Plastid x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Plastid x -> Plastid
$cfrom :: forall x. Plastid -> Rep Plastid x
Generic, Int -> Plastid -> ShowS
[Plastid] -> ShowS
Plastid -> String
(Int -> Plastid -> ShowS)
-> (Plastid -> String) -> ([Plastid] -> ShowS) -> Show Plastid
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Plastid] -> ShowS
$cshowList :: [Plastid] -> ShowS
show :: Plastid -> String
$cshow :: Plastid -> String
showsPrec :: Int -> Plastid -> ShowS
$cshowsPrec :: Int -> Plastid -> ShowS
Show, Plastid -> Plastid -> Bool
(Plastid -> Plastid -> Bool)
-> (Plastid -> Plastid -> Bool) -> Eq Plastid
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Plastid -> Plastid -> Bool
$c/= :: Plastid -> Plastid -> Bool
== :: Plastid -> Plastid -> Bool
$c== :: Plastid -> Plastid -> Bool
Eq, Eq Plastid
Eq Plastid
-> (Plastid -> Plastid -> Ordering)
-> (Plastid -> Plastid -> Bool)
-> (Plastid -> Plastid -> Bool)
-> (Plastid -> Plastid -> Bool)
-> (Plastid -> Plastid -> Bool)
-> (Plastid -> Plastid -> Plastid)
-> (Plastid -> Plastid -> Plastid)
-> Ord Plastid
Plastid -> Plastid -> Bool
Plastid -> Plastid -> Ordering
Plastid -> Plastid -> Plastid
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 :: Plastid -> Plastid -> Plastid
$cmin :: Plastid -> Plastid -> Plastid
max :: Plastid -> Plastid -> Plastid
$cmax :: Plastid -> Plastid -> Plastid
>= :: Plastid -> Plastid -> Bool
$c>= :: Plastid -> Plastid -> Bool
> :: Plastid -> Plastid -> Bool
$c> :: Plastid -> Plastid -> Bool
<= :: Plastid -> Plastid -> Bool
$c<= :: Plastid -> Plastid -> Bool
< :: Plastid -> Plastid -> Bool
$c< :: Plastid -> Plastid -> Bool
compare :: Plastid -> Plastid -> Ordering
$ccompare :: Plastid -> Plastid -> Ordering
$cp1Ord :: Eq Plastid
Ord, Plastid
Plastid -> Plastid -> Bounded Plastid
forall a. a -> a -> Bounded a
maxBound :: Plastid
$cmaxBound :: Plastid
minBound :: Plastid
$cminBound :: Plastid
Bounded, Int -> Plastid
Plastid -> Int
Plastid -> [Plastid]
Plastid -> Plastid
Plastid -> Plastid -> [Plastid]
Plastid -> Plastid -> Plastid -> [Plastid]
(Plastid -> Plastid)
-> (Plastid -> Plastid)
-> (Int -> Plastid)
-> (Plastid -> Int)
-> (Plastid -> [Plastid])
-> (Plastid -> Plastid -> [Plastid])
-> (Plastid -> Plastid -> [Plastid])
-> (Plastid -> Plastid -> Plastid -> [Plastid])
-> Enum Plastid
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Plastid -> Plastid -> Plastid -> [Plastid]
$cenumFromThenTo :: Plastid -> Plastid -> Plastid -> [Plastid]
enumFromTo :: Plastid -> Plastid -> [Plastid]
$cenumFromTo :: Plastid -> Plastid -> [Plastid]
enumFromThen :: Plastid -> Plastid -> [Plastid]
$cenumFromThen :: Plastid -> Plastid -> [Plastid]
enumFrom :: Plastid -> [Plastid]
$cenumFrom :: Plastid -> [Plastid]
fromEnum :: Plastid -> Int
$cfromEnum :: Plastid -> Int
toEnum :: Int -> Plastid
$ctoEnum :: Int -> Plastid
pred :: Plastid -> Plastid
$cpred :: Plastid -> Plastid
succ :: Plastid -> Plastid
$csucc :: Plastid -> Plastid
Enum)

-- | OrGanelle - indicates if the gene coding for a protein originates
--   from mitochondria, a plastid, a nucleomorph or a plasmid.
data OG = Hydrogenosome   -- ^ Hydrogenosomes are membrane-enclosed redox organelles found in some anaerobic unicellular eukaryotes which contain hydrogenase and produce hydrogen and ATP by glycolysis. They are thought to have evolved from mitochondria; most hydrogenosomes lack a genome, but some like (e.g. the anaerobic ciliate Nyctotherus ovalis) have retained a rudimentary genome.
        | Mitochondrion   -- ^ Mitochondria are redox-active membrane-bound organelles found in the cytoplasm of most eukaryotic cells. They are the site of sthe reactions of oxidative phosphorylation, which results in the formation of ATP.
        | Nucleomorph     -- ^ Nucleomorphs are reduced vestigal nuclei found in the plastids of cryptomonad and chlorachniophyte algae. The plastids originate from engulfed eukaryotic phototrophs.
        | Plasmid [Text]  -- ^ Plasmid with a specific name. If an entry reports the sequence of a protein identical in a number of plasmids, the names of these plasmids will all be listed.
        | Plastid Plastid -- ^ Plastids are classified based on either their taxonomic lineage or in some cases on their photosynthetic capacity.
  deriving ((forall x. OG -> Rep OG x)
-> (forall x. Rep OG x -> OG) -> Generic OG
forall x. Rep OG x -> OG
forall x. OG -> Rep OG x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OG x -> OG
$cfrom :: forall x. OG -> Rep OG x
Generic, Int -> OG -> ShowS
[OG] -> ShowS
OG -> String
(Int -> OG -> ShowS)
-> (OG -> String) -> ([OG] -> ShowS) -> Show OG
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OG] -> ShowS
$cshowList :: [OG] -> ShowS
show :: OG -> String
$cshow :: OG -> String
showsPrec :: Int -> OG -> ShowS
$cshowsPrec :: Int -> OG -> ShowS
Show, OG -> OG -> Bool
(OG -> OG -> Bool) -> (OG -> OG -> Bool) -> Eq OG
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OG -> OG -> Bool
$c/= :: OG -> OG -> Bool
== :: OG -> OG -> Bool
$c== :: OG -> OG -> Bool
Eq, Eq OG
Eq OG
-> (OG -> OG -> Ordering)
-> (OG -> OG -> Bool)
-> (OG -> OG -> Bool)
-> (OG -> OG -> Bool)
-> (OG -> OG -> Bool)
-> (OG -> OG -> OG)
-> (OG -> OG -> OG)
-> Ord OG
OG -> OG -> Bool
OG -> OG -> Ordering
OG -> OG -> OG
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 :: OG -> OG -> OG
$cmin :: OG -> OG -> OG
max :: OG -> OG -> OG
$cmax :: OG -> OG -> OG
>= :: OG -> OG -> Bool
$c>= :: OG -> OG -> Bool
> :: OG -> OG -> Bool
$c> :: OG -> OG -> Bool
<= :: OG -> OG -> Bool
$c<= :: OG -> OG -> Bool
< :: OG -> OG -> Bool
$c< :: OG -> OG -> Bool
compare :: OG -> OG -> Ordering
$ccompare :: OG -> OG -> Ordering
$cp1Ord :: Eq OG
Ord)

-- | Organism Classification - the taxonomic classification of the source organism.
newtype OC = OC
  { OC -> [Text]
nodes :: [Text]
  } deriving ((forall x. OC -> Rep OC x)
-> (forall x. Rep OC x -> OC) -> Generic OC
forall x. Rep OC x -> OC
forall x. OC -> Rep OC x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OC x -> OC
$cfrom :: forall x. OC -> Rep OC x
Generic, Int -> OC -> ShowS
[OC] -> ShowS
OC -> String
(Int -> OC -> ShowS)
-> (OC -> String) -> ([OC] -> ShowS) -> Show OC
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OC] -> ShowS
$cshowList :: [OC] -> ShowS
show :: OC -> String
$cshow :: OC -> String
showsPrec :: Int -> OC -> ShowS
$cshowsPrec :: Int -> OC -> ShowS
Show, OC -> OC -> Bool
(OC -> OC -> Bool) -> (OC -> OC -> Bool) -> Eq OC
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OC -> OC -> Bool
$c/= :: OC -> OC -> Bool
== :: OC -> OC -> Bool
$c== :: OC -> OC -> Bool
Eq, Eq OC
Eq OC
-> (OC -> OC -> Ordering)
-> (OC -> OC -> Bool)
-> (OC -> OC -> Bool)
-> (OC -> OC -> Bool)
-> (OC -> OC -> Bool)
-> (OC -> OC -> OC)
-> (OC -> OC -> OC)
-> Ord OC
OC -> OC -> Bool
OC -> OC -> Ordering
OC -> OC -> OC
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 :: OC -> OC -> OC
$cmin :: OC -> OC -> OC
max :: OC -> OC -> OC
$cmax :: OC -> OC -> OC
>= :: OC -> OC -> Bool
$c>= :: OC -> OC -> Bool
> :: OC -> OC -> Bool
$c> :: OC -> OC -> Bool
<= :: OC -> OC -> Bool
$c<= :: OC -> OC -> Bool
< :: OC -> OC -> Bool
$c< :: OC -> OC -> Bool
compare :: OC -> OC -> Ordering
$ccompare :: OC -> OC -> Ordering
$cp1Ord :: Eq OC
Ord)

-- | Organism taxonomy cross-reference indicates the identifier of a
--   specific organism in a taxonomic database.
data OX = OX
  { OX -> Text
databaseQualifier :: Text -- ^ Taxonomy database Qualifier
  , OX -> Text
taxonomicCode     :: Text -- ^ Taxonomic code
  } deriving ((forall x. OX -> Rep OX x)
-> (forall x. Rep OX x -> OX) -> Generic OX
forall x. Rep OX x -> OX
forall x. OX -> Rep OX x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OX x -> OX
$cfrom :: forall x. OX -> Rep OX x
Generic, Int -> OX -> ShowS
[OX] -> ShowS
OX -> String
(Int -> OX -> ShowS)
-> (OX -> String) -> ([OX] -> ShowS) -> Show OX
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OX] -> ShowS
$cshowList :: [OX] -> ShowS
show :: OX -> String
$cshow :: OX -> String
showsPrec :: Int -> OX -> ShowS
$cshowsPrec :: Int -> OX -> ShowS
Show, OX -> OX -> Bool
(OX -> OX -> Bool) -> (OX -> OX -> Bool) -> Eq OX
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OX -> OX -> Bool
$c/= :: OX -> OX -> Bool
== :: OX -> OX -> Bool
$c== :: OX -> OX -> Bool
Eq, Eq OX
Eq OX
-> (OX -> OX -> Ordering)
-> (OX -> OX -> Bool)
-> (OX -> OX -> Bool)
-> (OX -> OX -> Bool)
-> (OX -> OX -> Bool)
-> (OX -> OX -> OX)
-> (OX -> OX -> OX)
-> Ord OX
OX -> OX -> Bool
OX -> OX -> Ordering
OX -> OX -> OX
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 :: OX -> OX -> OX
$cmin :: OX -> OX -> OX
max :: OX -> OX -> OX
$cmax :: OX -> OX -> OX
>= :: OX -> OX -> Bool
$c>= :: OX -> OX -> Bool
> :: OX -> OX -> Bool
$c> :: OX -> OX -> Bool
<= :: OX -> OX -> Bool
$c<= :: OX -> OX -> Bool
< :: OX -> OX -> Bool
$c< :: OX -> OX -> Bool
compare :: OX -> OX -> Ordering
$ccompare :: OX -> OX -> Ordering
$cp1Ord :: Eq OX
Ord)

-- | Organism Host - indicates the host organism(s) that are susceptible 
--   to be infected by a virus. Appears only in viral entries.
data OH = OH
  { OH -> Text
taxId    :: Text -- ^
  , OH -> Text
hostName :: Text -- ^
  } deriving ((forall x. OH -> Rep OH x)
-> (forall x. Rep OH x -> OH) -> Generic OH
forall x. Rep OH x -> OH
forall x. OH -> Rep OH x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OH x -> OH
$cfrom :: forall x. OH -> Rep OH x
Generic, Int -> OH -> ShowS
[OH] -> ShowS
OH -> String
(Int -> OH -> ShowS)
-> (OH -> String) -> ([OH] -> ShowS) -> Show OH
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OH] -> ShowS
$cshowList :: [OH] -> ShowS
show :: OH -> String
$cshow :: OH -> String
showsPrec :: Int -> OH -> ShowS
$cshowsPrec :: Int -> OH -> ShowS
Show, OH -> OH -> Bool
(OH -> OH -> Bool) -> (OH -> OH -> Bool) -> Eq OH
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OH -> OH -> Bool
$c/= :: OH -> OH -> Bool
== :: OH -> OH -> Bool
$c== :: OH -> OH -> Bool
Eq, Eq OH
Eq OH
-> (OH -> OH -> Ordering)
-> (OH -> OH -> Bool)
-> (OH -> OH -> Bool)
-> (OH -> OH -> Bool)
-> (OH -> OH -> Bool)
-> (OH -> OH -> OH)
-> (OH -> OH -> OH)
-> Ord OH
OH -> OH -> Bool
OH -> OH -> Ordering
OH -> OH -> OH
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 :: OH -> OH -> OH
$cmin :: OH -> OH -> OH
max :: OH -> OH -> OH
$cmax :: OH -> OH -> OH
>= :: OH -> OH -> Bool
$c>= :: OH -> OH -> Bool
> :: OH -> OH -> Bool
$c> :: OH -> OH -> Bool
<= :: OH -> OH -> Bool
$c<= :: OH -> OH -> Bool
< :: OH -> OH -> Bool
$c< :: OH -> OH -> Bool
compare :: OH -> OH -> Ordering
$ccompare :: OH -> OH -> Ordering
$cp1Ord :: Eq OH
Ord)

-- | Reference comment token.
data Token = STRAIN
           | PLASMID
           | TRANSPOSON
           | TISSUE
  deriving ((forall x. Token -> Rep Token x)
-> (forall x. Rep Token x -> Token) -> Generic Token
forall x. Rep Token x -> Token
forall x. Token -> Rep Token x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Token x -> Token
$cfrom :: forall x. Token -> Rep Token x
Generic, Int -> Token -> ShowS
[Token] -> ShowS
Token -> String
(Int -> Token -> ShowS)
-> (Token -> String) -> ([Token] -> ShowS) -> Show Token
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Token] -> ShowS
$cshowList :: [Token] -> ShowS
show :: Token -> String
$cshow :: Token -> String
showsPrec :: Int -> Token -> ShowS
$cshowsPrec :: Int -> Token -> ShowS
Show, Token -> Token -> Bool
(Token -> Token -> Bool) -> (Token -> Token -> Bool) -> Eq Token
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Token -> Token -> Bool
$c/= :: Token -> Token -> Bool
== :: Token -> Token -> Bool
$c== :: Token -> Token -> Bool
Eq, Eq Token
Eq Token
-> (Token -> Token -> Ordering)
-> (Token -> Token -> Bool)
-> (Token -> Token -> Bool)
-> (Token -> Token -> Bool)
-> (Token -> Token -> Bool)
-> (Token -> Token -> Token)
-> (Token -> Token -> Token)
-> Ord Token
Token -> Token -> Bool
Token -> Token -> Ordering
Token -> Token -> Token
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 :: Token -> Token -> Token
$cmin :: Token -> Token -> Token
max :: Token -> Token -> Token
$cmax :: Token -> Token -> Token
>= :: Token -> Token -> Bool
$c>= :: Token -> Token -> Bool
> :: Token -> Token -> Bool
$c> :: Token -> Token -> Bool
<= :: Token -> Token -> Bool
$c<= :: Token -> Token -> Bool
< :: Token -> Token -> Bool
$c< :: Token -> Token -> Bool
compare :: Token -> Token -> Ordering
$ccompare :: Token -> Token -> Ordering
$cp1Ord :: Eq Token
Ord, Token
Token -> Token -> Bounded Token
forall a. a -> a -> Bounded a
maxBound :: Token
$cmaxBound :: Token
minBound :: Token
$cminBound :: Token
Bounded, Int -> Token
Token -> Int
Token -> [Token]
Token -> Token
Token -> Token -> [Token]
Token -> Token -> Token -> [Token]
(Token -> Token)
-> (Token -> Token)
-> (Int -> Token)
-> (Token -> Int)
-> (Token -> [Token])
-> (Token -> Token -> [Token])
-> (Token -> Token -> [Token])
-> (Token -> Token -> Token -> [Token])
-> Enum Token
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Token -> Token -> Token -> [Token]
$cenumFromThenTo :: Token -> Token -> Token -> [Token]
enumFromTo :: Token -> Token -> [Token]
$cenumFromTo :: Token -> Token -> [Token]
enumFromThen :: Token -> Token -> [Token]
$cenumFromThen :: Token -> Token -> [Token]
enumFrom :: Token -> [Token]
$cenumFrom :: Token -> [Token]
fromEnum :: Token -> Int
$cfromEnum :: Token -> Int
toEnum :: Int -> Token
$ctoEnum :: Int -> Token
pred :: Token -> Token
$cpred :: Token -> Token
succ :: Token -> Token
$csucc :: Token -> Token
Enum)

-- | Bibliographic database names.
data BibliographicDB = MEDLINE
                     | PubMed
                     | DOI
                     | AGRICOLA
  deriving ((forall x. BibliographicDB -> Rep BibliographicDB x)
-> (forall x. Rep BibliographicDB x -> BibliographicDB)
-> Generic BibliographicDB
forall x. Rep BibliographicDB x -> BibliographicDB
forall x. BibliographicDB -> Rep BibliographicDB x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BibliographicDB x -> BibliographicDB
$cfrom :: forall x. BibliographicDB -> Rep BibliographicDB x
Generic, Int -> BibliographicDB -> ShowS
[BibliographicDB] -> ShowS
BibliographicDB -> String
(Int -> BibliographicDB -> ShowS)
-> (BibliographicDB -> String)
-> ([BibliographicDB] -> ShowS)
-> Show BibliographicDB
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BibliographicDB] -> ShowS
$cshowList :: [BibliographicDB] -> ShowS
show :: BibliographicDB -> String
$cshow :: BibliographicDB -> String
showsPrec :: Int -> BibliographicDB -> ShowS
$cshowsPrec :: Int -> BibliographicDB -> ShowS
Show, BibliographicDB -> BibliographicDB -> Bool
(BibliographicDB -> BibliographicDB -> Bool)
-> (BibliographicDB -> BibliographicDB -> Bool)
-> Eq BibliographicDB
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BibliographicDB -> BibliographicDB -> Bool
$c/= :: BibliographicDB -> BibliographicDB -> Bool
== :: BibliographicDB -> BibliographicDB -> Bool
$c== :: BibliographicDB -> BibliographicDB -> Bool
Eq, Eq BibliographicDB
Eq BibliographicDB
-> (BibliographicDB -> BibliographicDB -> Ordering)
-> (BibliographicDB -> BibliographicDB -> Bool)
-> (BibliographicDB -> BibliographicDB -> Bool)
-> (BibliographicDB -> BibliographicDB -> Bool)
-> (BibliographicDB -> BibliographicDB -> Bool)
-> (BibliographicDB -> BibliographicDB -> BibliographicDB)
-> (BibliographicDB -> BibliographicDB -> BibliographicDB)
-> Ord BibliographicDB
BibliographicDB -> BibliographicDB -> Bool
BibliographicDB -> BibliographicDB -> Ordering
BibliographicDB -> BibliographicDB -> BibliographicDB
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 :: BibliographicDB -> BibliographicDB -> BibliographicDB
$cmin :: BibliographicDB -> BibliographicDB -> BibliographicDB
max :: BibliographicDB -> BibliographicDB -> BibliographicDB
$cmax :: BibliographicDB -> BibliographicDB -> BibliographicDB
>= :: BibliographicDB -> BibliographicDB -> Bool
$c>= :: BibliographicDB -> BibliographicDB -> Bool
> :: BibliographicDB -> BibliographicDB -> Bool
$c> :: BibliographicDB -> BibliographicDB -> Bool
<= :: BibliographicDB -> BibliographicDB -> Bool
$c<= :: BibliographicDB -> BibliographicDB -> Bool
< :: BibliographicDB -> BibliographicDB -> Bool
$c< :: BibliographicDB -> BibliographicDB -> Bool
compare :: BibliographicDB -> BibliographicDB -> Ordering
$ccompare :: BibliographicDB -> BibliographicDB -> Ordering
$cp1Ord :: Eq BibliographicDB
Ord, BibliographicDB
BibliographicDB -> BibliographicDB -> Bounded BibliographicDB
forall a. a -> a -> Bounded a
maxBound :: BibliographicDB
$cmaxBound :: BibliographicDB
minBound :: BibliographicDB
$cminBound :: BibliographicDB
Bounded, Int -> BibliographicDB
BibliographicDB -> Int
BibliographicDB -> [BibliographicDB]
BibliographicDB -> BibliographicDB
BibliographicDB -> BibliographicDB -> [BibliographicDB]
BibliographicDB
-> BibliographicDB -> BibliographicDB -> [BibliographicDB]
(BibliographicDB -> BibliographicDB)
-> (BibliographicDB -> BibliographicDB)
-> (Int -> BibliographicDB)
-> (BibliographicDB -> Int)
-> (BibliographicDB -> [BibliographicDB])
-> (BibliographicDB -> BibliographicDB -> [BibliographicDB])
-> (BibliographicDB -> BibliographicDB -> [BibliographicDB])
-> (BibliographicDB
    -> BibliographicDB -> BibliographicDB -> [BibliographicDB])
-> Enum BibliographicDB
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: BibliographicDB
-> BibliographicDB -> BibliographicDB -> [BibliographicDB]
$cenumFromThenTo :: BibliographicDB
-> BibliographicDB -> BibliographicDB -> [BibliographicDB]
enumFromTo :: BibliographicDB -> BibliographicDB -> [BibliographicDB]
$cenumFromTo :: BibliographicDB -> BibliographicDB -> [BibliographicDB]
enumFromThen :: BibliographicDB -> BibliographicDB -> [BibliographicDB]
$cenumFromThen :: BibliographicDB -> BibliographicDB -> [BibliographicDB]
enumFrom :: BibliographicDB -> [BibliographicDB]
$cenumFrom :: BibliographicDB -> [BibliographicDB]
fromEnum :: BibliographicDB -> Int
$cfromEnum :: BibliographicDB -> Int
toEnum :: Int -> BibliographicDB
$ctoEnum :: Int -> BibliographicDB
pred :: BibliographicDB -> BibliographicDB
$cpred :: BibliographicDB -> BibliographicDB
succ :: BibliographicDB -> BibliographicDB
$csucc :: BibliographicDB -> BibliographicDB
Enum)

-- | Reference Number - a sequential number to each reference citation in an entry.
data RN = RN
  { RN -> Int
number   :: Int
  , RN -> [Text]
evidence :: [Text]
  } deriving ((forall x. RN -> Rep RN x)
-> (forall x. Rep RN x -> RN) -> Generic RN
forall x. Rep RN x -> RN
forall x. RN -> Rep RN x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RN x -> RN
$cfrom :: forall x. RN -> Rep RN x
Generic, Int -> RN -> ShowS
[RN] -> ShowS
RN -> String
(Int -> RN -> ShowS)
-> (RN -> String) -> ([RN] -> ShowS) -> Show RN
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RN] -> ShowS
$cshowList :: [RN] -> ShowS
show :: RN -> String
$cshow :: RN -> String
showsPrec :: Int -> RN -> ShowS
$cshowsPrec :: Int -> RN -> ShowS
Show, RN -> RN -> Bool
(RN -> RN -> Bool) -> (RN -> RN -> Bool) -> Eq RN
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RN -> RN -> Bool
$c/= :: RN -> RN -> Bool
== :: RN -> RN -> Bool
$c== :: RN -> RN -> Bool
Eq, Eq RN
Eq RN
-> (RN -> RN -> Ordering)
-> (RN -> RN -> Bool)
-> (RN -> RN -> Bool)
-> (RN -> RN -> Bool)
-> (RN -> RN -> Bool)
-> (RN -> RN -> RN)
-> (RN -> RN -> RN)
-> Ord RN
RN -> RN -> Bool
RN -> RN -> Ordering
RN -> RN -> RN
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 :: RN -> RN -> RN
$cmin :: RN -> RN -> RN
max :: RN -> RN -> RN
$cmax :: RN -> RN -> RN
>= :: RN -> RN -> Bool
$c>= :: RN -> RN -> Bool
> :: RN -> RN -> Bool
$c> :: RN -> RN -> Bool
<= :: RN -> RN -> Bool
$c<= :: RN -> RN -> Bool
< :: RN -> RN -> Bool
$c< :: RN -> RN -> Bool
compare :: RN -> RN -> Ordering
$ccompare :: RN -> RN -> Ordering
$cp1Ord :: Eq RN
Ord)

-- | Reference lines.
data Reference = Reference
  { Reference -> Int
rn :: Int                       -- ^ Reference Number - a sequential number to each reference citation in an entry.
  , Reference -> Text
rp :: Text                      -- ^ Reference Position - the extent of the work relevant to the entry carried out by the authors.
  , Reference -> [(Token, Text)]
rc :: [(Token, Text)]           -- ^ Reference Comment - comments relevant to the reference cited.
  , Reference -> [(BibliographicDB, Text)]
rx :: [(BibliographicDB, Text)] -- ^ Reference cross-reference - the identifier assigned to a specific reference in a bibliographic database.
  , Reference -> [Text]
rg :: [Text]                    -- ^ Reference Group - the consortium name associated with a given citation.
  , Reference -> [Text]
ra :: [Text]                    -- ^ Reference Author - authors of the paper (or other work) cited.
  , Reference -> Maybe Text
rt :: Maybe Text                -- ^ Reference Title - the title of the paper (or other work) cited as exactly as possible given the limitations of the computer character set.
  , Reference -> Text
rl :: Text                      -- ^ Reference Location - he conventional citation information for the reference.
  } deriving ((forall x. Reference -> Rep Reference x)
-> (forall x. Rep Reference x -> Reference) -> Generic Reference
forall x. Rep Reference x -> Reference
forall x. Reference -> Rep Reference x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Reference x -> Reference
$cfrom :: forall x. Reference -> Rep Reference x
Generic, Int -> Reference -> ShowS
[Reference] -> ShowS
Reference -> String
(Int -> Reference -> ShowS)
-> (Reference -> String)
-> ([Reference] -> ShowS)
-> Show Reference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Reference] -> ShowS
$cshowList :: [Reference] -> ShowS
show :: Reference -> String
$cshow :: Reference -> String
showsPrec :: Int -> Reference -> ShowS
$cshowsPrec :: Int -> Reference -> ShowS
Show, Reference -> Reference -> Bool
(Reference -> Reference -> Bool)
-> (Reference -> Reference -> Bool) -> Eq Reference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Reference -> Reference -> Bool
$c/= :: Reference -> Reference -> Bool
== :: Reference -> Reference -> Bool
$c== :: Reference -> Reference -> Bool
Eq, Eq Reference
Eq Reference
-> (Reference -> Reference -> Ordering)
-> (Reference -> Reference -> Bool)
-> (Reference -> Reference -> Bool)
-> (Reference -> Reference -> Bool)
-> (Reference -> Reference -> Bool)
-> (Reference -> Reference -> Reference)
-> (Reference -> Reference -> Reference)
-> Ord Reference
Reference -> Reference -> Bool
Reference -> Reference -> Ordering
Reference -> Reference -> Reference
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 :: Reference -> Reference -> Reference
$cmin :: Reference -> Reference -> Reference
max :: Reference -> Reference -> Reference
$cmax :: Reference -> Reference -> Reference
>= :: Reference -> Reference -> Bool
$c>= :: Reference -> Reference -> Bool
> :: Reference -> Reference -> Bool
$c> :: Reference -> Reference -> Bool
<= :: Reference -> Reference -> Bool
$c<= :: Reference -> Reference -> Bool
< :: Reference -> Reference -> Bool
$c< :: Reference -> Reference -> Bool
compare :: Reference -> Reference -> Ordering
$ccompare :: Reference -> Reference -> Ordering
$cp1Ord :: Eq Reference
Ord)

-- | The comment blocks are arranged according to what we designate as 'topics'.
type Topic = Text

-- | Free text comments on the entry, and are used to convey any useful information.
data CC = CC
  { CC -> Text
topic   :: Topic
  , CC -> Text
comment :: Text
  } deriving ((forall x. CC -> Rep CC x)
-> (forall x. Rep CC x -> CC) -> Generic CC
forall x. Rep CC x -> CC
forall x. CC -> Rep CC x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CC x -> CC
$cfrom :: forall x. CC -> Rep CC x
Generic, Int -> CC -> ShowS
[CC] -> ShowS
CC -> String
(Int -> CC -> ShowS)
-> (CC -> String) -> ([CC] -> ShowS) -> Show CC
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CC] -> ShowS
$cshowList :: [CC] -> ShowS
show :: CC -> String
$cshow :: CC -> String
showsPrec :: Int -> CC -> ShowS
$cshowsPrec :: Int -> CC -> ShowS
Show, CC -> CC -> Bool
(CC -> CC -> Bool) -> (CC -> CC -> Bool) -> Eq CC
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CC -> CC -> Bool
$c/= :: CC -> CC -> Bool
== :: CC -> CC -> Bool
$c== :: CC -> CC -> Bool
Eq, Eq CC
Eq CC
-> (CC -> CC -> Ordering)
-> (CC -> CC -> Bool)
-> (CC -> CC -> Bool)
-> (CC -> CC -> Bool)
-> (CC -> CC -> Bool)
-> (CC -> CC -> CC)
-> (CC -> CC -> CC)
-> Ord CC
CC -> CC -> Bool
CC -> CC -> Ordering
CC -> CC -> CC
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 :: CC -> CC -> CC
$cmin :: CC -> CC -> CC
max :: CC -> CC -> CC
$cmax :: CC -> CC -> CC
>= :: CC -> CC -> Bool
$c>= :: CC -> CC -> Bool
> :: CC -> CC -> Bool
$c> :: CC -> CC -> Bool
<= :: CC -> CC -> Bool
$c<= :: CC -> CC -> Bool
< :: CC -> CC -> Bool
$c< :: CC -> CC -> Bool
compare :: CC -> CC -> Ordering
$ccompare :: CC -> CC -> Ordering
$cp1Ord :: Eq CC
Ord)

-- | Database cross-Reference - pointers to information in external
--   data resources that is related to UniProtKB entries.
data DR = DR
  { DR -> Text
resourceAbbr :: Text   -- ^ The abbreviated name of the referenced resource (e.g. PDB).
  , DR -> Text
resourceId   :: Text   -- ^ An unambiguous pointer to a record in the referenced resource.
  , DR -> [Text]
optionalInfo :: [Text] -- ^ Used to provide optional information.
  } deriving ((forall x. DR -> Rep DR x)
-> (forall x. Rep DR x -> DR) -> Generic DR
forall x. Rep DR x -> DR
forall x. DR -> Rep DR x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DR x -> DR
$cfrom :: forall x. DR -> Rep DR x
Generic, Int -> DR -> ShowS
[DR] -> ShowS
DR -> String
(Int -> DR -> ShowS)
-> (DR -> String) -> ([DR] -> ShowS) -> Show DR
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DR] -> ShowS
$cshowList :: [DR] -> ShowS
show :: DR -> String
$cshow :: DR -> String
showsPrec :: Int -> DR -> ShowS
$cshowsPrec :: Int -> DR -> ShowS
Show, DR -> DR -> Bool
(DR -> DR -> Bool) -> (DR -> DR -> Bool) -> Eq DR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DR -> DR -> Bool
$c/= :: DR -> DR -> Bool
== :: DR -> DR -> Bool
$c== :: DR -> DR -> Bool
Eq, Eq DR
Eq DR
-> (DR -> DR -> Ordering)
-> (DR -> DR -> Bool)
-> (DR -> DR -> Bool)
-> (DR -> DR -> Bool)
-> (DR -> DR -> Bool)
-> (DR -> DR -> DR)
-> (DR -> DR -> DR)
-> Ord DR
DR -> DR -> Bool
DR -> DR -> Ordering
DR -> DR -> DR
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 :: DR -> DR -> DR
$cmin :: DR -> DR -> DR
max :: DR -> DR -> DR
$cmax :: DR -> DR -> DR
>= :: DR -> DR -> Bool
$c>= :: DR -> DR -> Bool
> :: DR -> DR -> Bool
$c> :: DR -> DR -> Bool
<= :: DR -> DR -> Bool
$c<= :: DR -> DR -> Bool
< :: DR -> DR -> Bool
$c< :: DR -> DR -> Bool
compare :: DR -> DR -> Ordering
$ccompare :: DR -> DR -> Ordering
$cp1Ord :: Eq DR
Ord)

-- | Protein existence - indication on the evidences that we currently
--   have for the existence of a protein. Because most protein sequences
--   are derived from translation of nucleotide sequences and are mere
--   predictions, the PE line indicates what the evidences are of the
--   existence of a protein.
data PE = EvidenceAtProteinLevel
        | EvidenceAtTranscriptLevel
        | InferredFromHomology
        | Predicted
        | Uncertain
  deriving ((forall x. PE -> Rep PE x)
-> (forall x. Rep PE x -> PE) -> Generic PE
forall x. Rep PE x -> PE
forall x. PE -> Rep PE x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PE x -> PE
$cfrom :: forall x. PE -> Rep PE x
Generic, Int -> PE -> ShowS
[PE] -> ShowS
PE -> String
(Int -> PE -> ShowS)
-> (PE -> String) -> ([PE] -> ShowS) -> Show PE
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PE] -> ShowS
$cshowList :: [PE] -> ShowS
show :: PE -> String
$cshow :: PE -> String
showsPrec :: Int -> PE -> ShowS
$cshowsPrec :: Int -> PE -> ShowS
Show, PE -> PE -> Bool
(PE -> PE -> Bool) -> (PE -> PE -> Bool) -> Eq PE
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PE -> PE -> Bool
$c/= :: PE -> PE -> Bool
== :: PE -> PE -> Bool
$c== :: PE -> PE -> Bool
Eq, Eq PE
Eq PE
-> (PE -> PE -> Ordering)
-> (PE -> PE -> Bool)
-> (PE -> PE -> Bool)
-> (PE -> PE -> Bool)
-> (PE -> PE -> Bool)
-> (PE -> PE -> PE)
-> (PE -> PE -> PE)
-> Ord PE
PE -> PE -> Bool
PE -> PE -> Ordering
PE -> PE -> PE
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 :: PE -> PE -> PE
$cmin :: PE -> PE -> PE
max :: PE -> PE -> PE
$cmax :: PE -> PE -> PE
>= :: PE -> PE -> Bool
$c>= :: PE -> PE -> Bool
> :: PE -> PE -> Bool
$c> :: PE -> PE -> Bool
<= :: PE -> PE -> Bool
$c<= :: PE -> PE -> Bool
< :: PE -> PE -> Bool
$c< :: PE -> PE -> Bool
compare :: PE -> PE -> Ordering
$ccompare :: PE -> PE -> Ordering
$cp1Ord :: Eq PE
Ord)

-- | KeyWord - information that can be used to generate indexes of the
--   sequence entries based on functional, structural, or other categories.
newtype KW = KW
  { KW -> [Text]
keywords :: [Text]
  } deriving ((forall x. KW -> Rep KW x)
-> (forall x. Rep KW x -> KW) -> Generic KW
forall x. Rep KW x -> KW
forall x. KW -> Rep KW x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep KW x -> KW
$cfrom :: forall x. KW -> Rep KW x
Generic, Int -> KW -> ShowS
[KW] -> ShowS
KW -> String
(Int -> KW -> ShowS)
-> (KW -> String) -> ([KW] -> ShowS) -> Show KW
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [KW] -> ShowS
$cshowList :: [KW] -> ShowS
show :: KW -> String
$cshow :: KW -> String
showsPrec :: Int -> KW -> ShowS
$cshowsPrec :: Int -> KW -> ShowS
Show, KW -> KW -> Bool
(KW -> KW -> Bool) -> (KW -> KW -> Bool) -> Eq KW
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: KW -> KW -> Bool
$c/= :: KW -> KW -> Bool
== :: KW -> KW -> Bool
$c== :: KW -> KW -> Bool
Eq, Eq KW
Eq KW
-> (KW -> KW -> Ordering)
-> (KW -> KW -> Bool)
-> (KW -> KW -> Bool)
-> (KW -> KW -> Bool)
-> (KW -> KW -> Bool)
-> (KW -> KW -> KW)
-> (KW -> KW -> KW)
-> Ord KW
KW -> KW -> Bool
KW -> KW -> Ordering
KW -> KW -> KW
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 :: KW -> KW -> KW
$cmin :: KW -> KW -> KW
max :: KW -> KW -> KW
$cmax :: KW -> KW -> KW
>= :: KW -> KW -> Bool
$c>= :: KW -> KW -> Bool
> :: KW -> KW -> Bool
$c> :: KW -> KW -> Bool
<= :: KW -> KW -> Bool
$c<= :: KW -> KW -> Bool
< :: KW -> KW -> Bool
$c< :: KW -> KW -> Bool
compare :: KW -> KW -> Ordering
$ccompare :: KW -> KW -> Ordering
$cp1Ord :: Eq KW
Ord)

data Endpoint = ExactEP Int
              | NTerminalEP Int
              | CTerminalEP Int
              | UncertainEP Int
              | UnknownEP
  deriving ((forall x. Endpoint -> Rep Endpoint x)
-> (forall x. Rep Endpoint x -> Endpoint) -> Generic Endpoint
forall x. Rep Endpoint x -> Endpoint
forall x. Endpoint -> Rep Endpoint x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Endpoint x -> Endpoint
$cfrom :: forall x. Endpoint -> Rep Endpoint x
Generic, Int -> Endpoint -> ShowS
[Endpoint] -> ShowS
Endpoint -> String
(Int -> Endpoint -> ShowS)
-> (Endpoint -> String) -> ([Endpoint] -> ShowS) -> Show Endpoint
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Endpoint] -> ShowS
$cshowList :: [Endpoint] -> ShowS
show :: Endpoint -> String
$cshow :: Endpoint -> String
showsPrec :: Int -> Endpoint -> ShowS
$cshowsPrec :: Int -> Endpoint -> ShowS
Show, Endpoint -> Endpoint -> Bool
(Endpoint -> Endpoint -> Bool)
-> (Endpoint -> Endpoint -> Bool) -> Eq Endpoint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Endpoint -> Endpoint -> Bool
$c/= :: Endpoint -> Endpoint -> Bool
== :: Endpoint -> Endpoint -> Bool
$c== :: Endpoint -> Endpoint -> Bool
Eq, Eq Endpoint
Eq Endpoint
-> (Endpoint -> Endpoint -> Ordering)
-> (Endpoint -> Endpoint -> Bool)
-> (Endpoint -> Endpoint -> Bool)
-> (Endpoint -> Endpoint -> Bool)
-> (Endpoint -> Endpoint -> Bool)
-> (Endpoint -> Endpoint -> Endpoint)
-> (Endpoint -> Endpoint -> Endpoint)
-> Ord Endpoint
Endpoint -> Endpoint -> Bool
Endpoint -> Endpoint -> Ordering
Endpoint -> Endpoint -> Endpoint
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 :: Endpoint -> Endpoint -> Endpoint
$cmin :: Endpoint -> Endpoint -> Endpoint
max :: Endpoint -> Endpoint -> Endpoint
$cmax :: Endpoint -> Endpoint -> Endpoint
>= :: Endpoint -> Endpoint -> Bool
$c>= :: Endpoint -> Endpoint -> Bool
> :: Endpoint -> Endpoint -> Bool
$c> :: Endpoint -> Endpoint -> Bool
<= :: Endpoint -> Endpoint -> Bool
$c<= :: Endpoint -> Endpoint -> Bool
< :: Endpoint -> Endpoint -> Bool
$c< :: Endpoint -> Endpoint -> Bool
compare :: Endpoint -> Endpoint -> Ordering
$ccompare :: Endpoint -> Endpoint -> Ordering
$cp1Ord :: Eq Endpoint
Ord)

-- | Feature Table - means for the annotation of the sequence data.
data FT = FT
  { FT -> Text
keyName     :: Text     -- ^ Key name.
  , FT -> Endpoint
fromEP      :: Endpoint -- ^ 'From' endpoint.
  , FT -> Endpoint
toEP        :: Endpoint -- ^ 'To' endpoint.
  , FT -> [Text]
description :: [Text]   -- ^ Description.
  } deriving ((forall x. FT -> Rep FT x)
-> (forall x. Rep FT x -> FT) -> Generic FT
forall x. Rep FT x -> FT
forall x. FT -> Rep FT x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FT x -> FT
$cfrom :: forall x. FT -> Rep FT x
Generic, Int -> FT -> ShowS
[FT] -> ShowS
FT -> String
(Int -> FT -> ShowS)
-> (FT -> String) -> ([FT] -> ShowS) -> Show FT
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FT] -> ShowS
$cshowList :: [FT] -> ShowS
show :: FT -> String
$cshow :: FT -> String
showsPrec :: Int -> FT -> ShowS
$cshowsPrec :: Int -> FT -> ShowS
Show, FT -> FT -> Bool
(FT -> FT -> Bool) -> (FT -> FT -> Bool) -> Eq FT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FT -> FT -> Bool
$c/= :: FT -> FT -> Bool
== :: FT -> FT -> Bool
$c== :: FT -> FT -> Bool
Eq, Eq FT
Eq FT
-> (FT -> FT -> Ordering)
-> (FT -> FT -> Bool)
-> (FT -> FT -> Bool)
-> (FT -> FT -> Bool)
-> (FT -> FT -> Bool)
-> (FT -> FT -> FT)
-> (FT -> FT -> FT)
-> Ord FT
FT -> FT -> Bool
FT -> FT -> Ordering
FT -> FT -> FT
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 :: FT -> FT -> FT
$cmin :: FT -> FT -> FT
max :: FT -> FT -> FT
$cmax :: FT -> FT -> FT
>= :: FT -> FT -> Bool
$c>= :: FT -> FT -> Bool
> :: FT -> FT -> Bool
$c> :: FT -> FT -> Bool
<= :: FT -> FT -> Bool
$c<= :: FT -> FT -> Bool
< :: FT -> FT -> Bool
$c< :: FT -> FT -> Bool
compare :: FT -> FT -> Ordering
$ccompare :: FT -> FT -> Ordering
$cp1Ord :: Eq FT
Ord)

-- | SeQuence header - sequence data and a quick summary of its content.
data SQ = SQ
  { SQ -> Int
len       :: Int  -- ^ Length of the sequence in amino acids.
  , SQ -> Int
molWeight :: Int  -- ^ Molecular weight rounded to the nearest mass unit (Dalton).
  , SQ -> Text
crc64     :: Text -- ^ Sequence 64-bit CRC (Cyclic Redundancy Check) value.
  , SQ -> Text
sequ      :: Text -- ^ Sequence of the protein
  } deriving ((forall x. SQ -> Rep SQ x)
-> (forall x. Rep SQ x -> SQ) -> Generic SQ
forall x. Rep SQ x -> SQ
forall x. SQ -> Rep SQ x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SQ x -> SQ
$cfrom :: forall x. SQ -> Rep SQ x
Generic, Int -> SQ -> ShowS
[SQ] -> ShowS
SQ -> String
(Int -> SQ -> ShowS)
-> (SQ -> String) -> ([SQ] -> ShowS) -> Show SQ
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SQ] -> ShowS
$cshowList :: [SQ] -> ShowS
show :: SQ -> String
$cshow :: SQ -> String
showsPrec :: Int -> SQ -> ShowS
$cshowsPrec :: Int -> SQ -> ShowS
Show, SQ -> SQ -> Bool
(SQ -> SQ -> Bool) -> (SQ -> SQ -> Bool) -> Eq SQ
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SQ -> SQ -> Bool
$c/= :: SQ -> SQ -> Bool
== :: SQ -> SQ -> Bool
$c== :: SQ -> SQ -> Bool
Eq, Eq SQ
Eq SQ
-> (SQ -> SQ -> Ordering)
-> (SQ -> SQ -> Bool)
-> (SQ -> SQ -> Bool)
-> (SQ -> SQ -> Bool)
-> (SQ -> SQ -> Bool)
-> (SQ -> SQ -> SQ)
-> (SQ -> SQ -> SQ)
-> Ord SQ
SQ -> SQ -> Bool
SQ -> SQ -> Ordering
SQ -> SQ -> SQ
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 :: SQ -> SQ -> SQ
$cmin :: SQ -> SQ -> SQ
max :: SQ -> SQ -> SQ
$cmax :: SQ -> SQ -> SQ
>= :: SQ -> SQ -> Bool
$c>= :: SQ -> SQ -> Bool
> :: SQ -> SQ -> Bool
$c> :: SQ -> SQ -> Bool
<= :: SQ -> SQ -> Bool
$c<= :: SQ -> SQ -> Bool
< :: SQ -> SQ -> Bool
$c< :: SQ -> SQ -> Bool
compare :: SQ -> SQ -> Ordering
$ccompare :: SQ -> SQ -> Ordering
$cp1Ord :: Eq SQ
Ord)

-- | Full UniProt record in UniProt-KB format.
data Record = Record
  { Record -> ID
id   :: ID
  , Record -> AC
ac   :: AC
  , Record -> DT
dt   :: DT
  , Record -> DE
de   :: DE
  , Record -> [GN]
gn   :: [GN]
  , Record -> OS
os   :: OS
  , Record -> [OG]
og   :: [OG]
  , Record -> OC
oc   :: OC
  , Record -> OX
ox   :: OX
  , Record -> [OH]
oh   :: [OH]
  , Record -> [Reference]
refs :: [Reference]
  , Record -> [CC]
cc   :: [CC]
  , Record -> [DR]
dr   :: [DR]
  , Record -> PE
pe   :: PE
  , Record -> Maybe KW
kw   :: Maybe KW
  , Record -> [FT]
ft   :: [FT]
  , Record -> SQ
sq   :: SQ
  } deriving ((forall x. Record -> Rep Record x)
-> (forall x. Rep Record x -> Record) -> Generic Record
forall x. Rep Record x -> Record
forall x. Record -> Rep Record x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Record x -> Record
$cfrom :: forall x. Record -> Rep Record x
Generic, Int -> Record -> ShowS
[Record] -> ShowS
Record -> String
(Int -> Record -> ShowS)
-> (Record -> String) -> ([Record] -> ShowS) -> Show Record
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Record] -> ShowS
$cshowList :: [Record] -> ShowS
show :: Record -> String
$cshow :: Record -> String
showsPrec :: Int -> Record -> ShowS
$cshowsPrec :: Int -> Record -> ShowS
Show, Record -> Record -> Bool
(Record -> Record -> Bool)
-> (Record -> Record -> Bool) -> Eq Record
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Record -> Record -> Bool
$c/= :: Record -> Record -> Bool
== :: Record -> Record -> Bool
$c== :: Record -> Record -> Bool
Eq, Eq Record
Eq Record
-> (Record -> Record -> Ordering)
-> (Record -> Record -> Bool)
-> (Record -> Record -> Bool)
-> (Record -> Record -> Bool)
-> (Record -> Record -> Bool)
-> (Record -> Record -> Record)
-> (Record -> Record -> Record)
-> Ord Record
Record -> Record -> Bool
Record -> Record -> Ordering
Record -> Record -> Record
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 :: Record -> Record -> Record
$cmin :: Record -> Record -> Record
max :: Record -> Record -> Record
$cmax :: Record -> Record -> Record
>= :: Record -> Record -> Bool
$c>= :: Record -> Record -> Bool
> :: Record -> Record -> Bool
$c> :: Record -> Record -> Bool
<= :: Record -> Record -> Bool
$c<= :: Record -> Record -> Bool
< :: Record -> Record -> Bool
$c< :: Record -> Record -> Bool
compare :: Record -> Record -> Ordering
$ccompare :: Record -> Record -> Ordering
$cp1Ord :: Eq Record
Ord)