-- | Wrappers for structural data. Encoded as bytestrings. This differs from
-- @BiobaseXNA@, where specialized encodings are used. These structures are
-- supposedly "short", they need to fit into a strict bytestring.
--
-- TODO Consider where to move each type. There are merge possibilities between
-- BiobaseXNA and BiobaseTypes.
--
-- TODO QuickCheck @Arbitrary@ for @RNAss@.

module Biobase.Types.Structure where

import           Control.Applicative
import           Control.DeepSeq
import           Control.Lens
import           Control.Monad.Error.Class
import           Control.Monad (foldM,unless)
import           Data.Attoparsec.ByteString.Char8
import           Data.Attoparsec.Combinator
import           Data.Bifunctor (second)
import           Data.ByteString (ByteString)
import           Data.Data
import           Data.List (foldl1',foldl')
import           Data.Monoid ((<>))
import           Data.Set (Set)
import           GHC.Generics (Generic)
import qualified Data.ByteString.Char8 as BS8
import qualified Data.List as L
import qualified Data.Set as S
import qualified Data.Set as Set
import qualified Data.Vector.Unboxed as VU
import qualified Test.QuickCheck as Q

import           Data.Forest.StructuredPaired



-- | Secondary structure using @()@ for paired elements, and @.@ for unpaired
-- ones. It is assumed that the @()@ match up. These structures from a Monoid.

newtype RNAss = RNAss { RNAss -> ByteString
_rnass ∷ ByteString }
  deriving (RNAss -> RNAss -> Bool
(RNAss -> RNAss -> Bool) -> (RNAss -> RNAss -> Bool) -> Eq RNAss
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RNAss -> RNAss -> Bool
$c/= :: RNAss -> RNAss -> Bool
== :: RNAss -> RNAss -> Bool
$c== :: RNAss -> RNAss -> Bool
Eq,Eq RNAss
Eq RNAss
-> (RNAss -> RNAss -> Ordering)
-> (RNAss -> RNAss -> Bool)
-> (RNAss -> RNAss -> Bool)
-> (RNAss -> RNAss -> Bool)
-> (RNAss -> RNAss -> Bool)
-> (RNAss -> RNAss -> RNAss)
-> (RNAss -> RNAss -> RNAss)
-> Ord RNAss
RNAss -> RNAss -> Bool
RNAss -> RNAss -> Ordering
RNAss -> RNAss -> RNAss
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 :: RNAss -> RNAss -> RNAss
$cmin :: RNAss -> RNAss -> RNAss
max :: RNAss -> RNAss -> RNAss
$cmax :: RNAss -> RNAss -> RNAss
>= :: RNAss -> RNAss -> Bool
$c>= :: RNAss -> RNAss -> Bool
> :: RNAss -> RNAss -> Bool
$c> :: RNAss -> RNAss -> Bool
<= :: RNAss -> RNAss -> Bool
$c<= :: RNAss -> RNAss -> Bool
< :: RNAss -> RNAss -> Bool
$c< :: RNAss -> RNAss -> Bool
compare :: RNAss -> RNAss -> Ordering
$ccompare :: RNAss -> RNAss -> Ordering
$cp1Ord :: Eq RNAss
Ord,Int -> RNAss -> ShowS
[RNAss] -> ShowS
RNAss -> String
(Int -> RNAss -> ShowS)
-> (RNAss -> String) -> ([RNAss] -> ShowS) -> Show RNAss
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RNAss] -> ShowS
$cshowList :: [RNAss] -> ShowS
show :: RNAss -> String
$cshow :: RNAss -> String
showsPrec :: Int -> RNAss -> ShowS
$cshowsPrec :: Int -> RNAss -> ShowS
Show,ReadPrec [RNAss]
ReadPrec RNAss
Int -> ReadS RNAss
ReadS [RNAss]
(Int -> ReadS RNAss)
-> ReadS [RNAss]
-> ReadPrec RNAss
-> ReadPrec [RNAss]
-> Read RNAss
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RNAss]
$creadListPrec :: ReadPrec [RNAss]
readPrec :: ReadPrec RNAss
$creadPrec :: ReadPrec RNAss
readList :: ReadS [RNAss]
$creadList :: ReadS [RNAss]
readsPrec :: Int -> ReadS RNAss
$creadsPrec :: Int -> ReadS RNAss
Read,Typeable RNAss
DataType
Constr
Typeable RNAss
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RNAss -> c RNAss)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RNAss)
-> (RNAss -> Constr)
-> (RNAss -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RNAss))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RNAss))
-> ((forall b. Data b => b -> b) -> RNAss -> RNAss)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RNAss -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RNAss -> r)
-> (forall u. (forall d. Data d => d -> u) -> RNAss -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RNAss -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RNAss -> m RNAss)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RNAss -> m RNAss)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RNAss -> m RNAss)
-> Data RNAss
RNAss -> DataType
RNAss -> Constr
(forall b. Data b => b -> b) -> RNAss -> RNAss
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RNAss -> c RNAss
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RNAss
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RNAss -> u
forall u. (forall d. Data d => d -> u) -> RNAss -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RNAss -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RNAss -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RNAss -> m RNAss
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RNAss -> m RNAss
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RNAss
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RNAss -> c RNAss
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RNAss)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RNAss)
$cRNAss :: Constr
$tRNAss :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> RNAss -> m RNAss
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RNAss -> m RNAss
gmapMp :: (forall d. Data d => d -> m d) -> RNAss -> m RNAss
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RNAss -> m RNAss
gmapM :: (forall d. Data d => d -> m d) -> RNAss -> m RNAss
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RNAss -> m RNAss
gmapQi :: Int -> (forall d. Data d => d -> u) -> RNAss -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RNAss -> u
gmapQ :: (forall d. Data d => d -> u) -> RNAss -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RNAss -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RNAss -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RNAss -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RNAss -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RNAss -> r
gmapT :: (forall b. Data b => b -> b) -> RNAss -> RNAss
$cgmapT :: (forall b. Data b => b -> b) -> RNAss -> RNAss
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RNAss)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RNAss)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c RNAss)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RNAss)
dataTypeOf :: RNAss -> DataType
$cdataTypeOf :: RNAss -> DataType
toConstr :: RNAss -> Constr
$ctoConstr :: RNAss -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RNAss
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RNAss
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RNAss -> c RNAss
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RNAss -> c RNAss
$cp1Data :: Typeable RNAss
Data,Typeable,(forall x. RNAss -> Rep RNAss x)
-> (forall x. Rep RNAss x -> RNAss) -> Generic RNAss
forall x. Rep RNAss x -> RNAss
forall x. RNAss -> Rep RNAss x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RNAss x -> RNAss
$cfrom :: forall x. RNAss -> Rep RNAss x
Generic,b -> RNAss -> RNAss
NonEmpty RNAss -> RNAss
RNAss -> RNAss -> RNAss
(RNAss -> RNAss -> RNAss)
-> (NonEmpty RNAss -> RNAss)
-> (forall b. Integral b => b -> RNAss -> RNAss)
-> Semigroup RNAss
forall b. Integral b => b -> RNAss -> RNAss
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> RNAss -> RNAss
$cstimes :: forall b. Integral b => b -> RNAss -> RNAss
sconcat :: NonEmpty RNAss -> RNAss
$csconcat :: NonEmpty RNAss -> RNAss
<> :: RNAss -> RNAss -> RNAss
$c<> :: RNAss -> RNAss -> RNAss
Semigroup,Semigroup RNAss
RNAss
Semigroup RNAss
-> RNAss
-> (RNAss -> RNAss -> RNAss)
-> ([RNAss] -> RNAss)
-> Monoid RNAss
[RNAss] -> RNAss
RNAss -> RNAss -> RNAss
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
mconcat :: [RNAss] -> RNAss
$cmconcat :: [RNAss] -> RNAss
mappend :: RNAss -> RNAss -> RNAss
$cmappend :: RNAss -> RNAss -> RNAss
mempty :: RNAss
$cmempty :: RNAss
$cp1Monoid :: Semigroup RNAss
Monoid)
makeLenses ''RNAss

instance NFData RNAss

-- | Ensemble structure encoding. *Very* different type ctor name chosen! The
-- structure of this string makes verification much more complicated.
--
-- TODO describe encoding used by RNAfold for the ensemble string.

newtype RNAensembleStructure = RNAes { RNAensembleStructure -> ByteString
_rnaes ∷ ByteString }
  deriving (RNAensembleStructure -> RNAensembleStructure -> Bool
(RNAensembleStructure -> RNAensembleStructure -> Bool)
-> (RNAensembleStructure -> RNAensembleStructure -> Bool)
-> Eq RNAensembleStructure
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RNAensembleStructure -> RNAensembleStructure -> Bool
$c/= :: RNAensembleStructure -> RNAensembleStructure -> Bool
== :: RNAensembleStructure -> RNAensembleStructure -> Bool
$c== :: RNAensembleStructure -> RNAensembleStructure -> Bool
Eq,Eq RNAensembleStructure
Eq RNAensembleStructure
-> (RNAensembleStructure -> RNAensembleStructure -> Ordering)
-> (RNAensembleStructure -> RNAensembleStructure -> Bool)
-> (RNAensembleStructure -> RNAensembleStructure -> Bool)
-> (RNAensembleStructure -> RNAensembleStructure -> Bool)
-> (RNAensembleStructure -> RNAensembleStructure -> Bool)
-> (RNAensembleStructure
    -> RNAensembleStructure -> RNAensembleStructure)
-> (RNAensembleStructure
    -> RNAensembleStructure -> RNAensembleStructure)
-> Ord RNAensembleStructure
RNAensembleStructure -> RNAensembleStructure -> Bool
RNAensembleStructure -> RNAensembleStructure -> Ordering
RNAensembleStructure
-> RNAensembleStructure -> RNAensembleStructure
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 :: RNAensembleStructure
-> RNAensembleStructure -> RNAensembleStructure
$cmin :: RNAensembleStructure
-> RNAensembleStructure -> RNAensembleStructure
max :: RNAensembleStructure
-> RNAensembleStructure -> RNAensembleStructure
$cmax :: RNAensembleStructure
-> RNAensembleStructure -> RNAensembleStructure
>= :: RNAensembleStructure -> RNAensembleStructure -> Bool
$c>= :: RNAensembleStructure -> RNAensembleStructure -> Bool
> :: RNAensembleStructure -> RNAensembleStructure -> Bool
$c> :: RNAensembleStructure -> RNAensembleStructure -> Bool
<= :: RNAensembleStructure -> RNAensembleStructure -> Bool
$c<= :: RNAensembleStructure -> RNAensembleStructure -> Bool
< :: RNAensembleStructure -> RNAensembleStructure -> Bool
$c< :: RNAensembleStructure -> RNAensembleStructure -> Bool
compare :: RNAensembleStructure -> RNAensembleStructure -> Ordering
$ccompare :: RNAensembleStructure -> RNAensembleStructure -> Ordering
$cp1Ord :: Eq RNAensembleStructure
Ord,Int -> RNAensembleStructure -> ShowS
[RNAensembleStructure] -> ShowS
RNAensembleStructure -> String
(Int -> RNAensembleStructure -> ShowS)
-> (RNAensembleStructure -> String)
-> ([RNAensembleStructure] -> ShowS)
-> Show RNAensembleStructure
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RNAensembleStructure] -> ShowS
$cshowList :: [RNAensembleStructure] -> ShowS
show :: RNAensembleStructure -> String
$cshow :: RNAensembleStructure -> String
showsPrec :: Int -> RNAensembleStructure -> ShowS
$cshowsPrec :: Int -> RNAensembleStructure -> ShowS
Show,ReadPrec [RNAensembleStructure]
ReadPrec RNAensembleStructure
Int -> ReadS RNAensembleStructure
ReadS [RNAensembleStructure]
(Int -> ReadS RNAensembleStructure)
-> ReadS [RNAensembleStructure]
-> ReadPrec RNAensembleStructure
-> ReadPrec [RNAensembleStructure]
-> Read RNAensembleStructure
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RNAensembleStructure]
$creadListPrec :: ReadPrec [RNAensembleStructure]
readPrec :: ReadPrec RNAensembleStructure
$creadPrec :: ReadPrec RNAensembleStructure
readList :: ReadS [RNAensembleStructure]
$creadList :: ReadS [RNAensembleStructure]
readsPrec :: Int -> ReadS RNAensembleStructure
$creadsPrec :: Int -> ReadS RNAensembleStructure
Read,Typeable RNAensembleStructure
DataType
Constr
Typeable RNAensembleStructure
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> RNAensembleStructure
    -> c RNAensembleStructure)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RNAensembleStructure)
-> (RNAensembleStructure -> Constr)
-> (RNAensembleStructure -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RNAensembleStructure))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RNAensembleStructure))
-> ((forall b. Data b => b -> b)
    -> RNAensembleStructure -> RNAensembleStructure)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RNAensembleStructure -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RNAensembleStructure -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> RNAensembleStructure -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RNAensembleStructure -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> RNAensembleStructure -> m RNAensembleStructure)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RNAensembleStructure -> m RNAensembleStructure)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RNAensembleStructure -> m RNAensembleStructure)
-> Data RNAensembleStructure
RNAensembleStructure -> DataType
RNAensembleStructure -> Constr
(forall b. Data b => b -> b)
-> RNAensembleStructure -> RNAensembleStructure
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> RNAensembleStructure
-> c RNAensembleStructure
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RNAensembleStructure
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> RNAensembleStructure -> u
forall u.
(forall d. Data d => d -> u) -> RNAensembleStructure -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RNAensembleStructure -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RNAensembleStructure -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RNAensembleStructure -> m RNAensembleStructure
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RNAensembleStructure -> m RNAensembleStructure
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RNAensembleStructure
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> RNAensembleStructure
-> c RNAensembleStructure
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RNAensembleStructure)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RNAensembleStructure)
$cRNAes :: Constr
$tRNAensembleStructure :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> RNAensembleStructure -> m RNAensembleStructure
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RNAensembleStructure -> m RNAensembleStructure
gmapMp :: (forall d. Data d => d -> m d)
-> RNAensembleStructure -> m RNAensembleStructure
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RNAensembleStructure -> m RNAensembleStructure
gmapM :: (forall d. Data d => d -> m d)
-> RNAensembleStructure -> m RNAensembleStructure
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RNAensembleStructure -> m RNAensembleStructure
gmapQi :: Int -> (forall d. Data d => d -> u) -> RNAensembleStructure -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> RNAensembleStructure -> u
gmapQ :: (forall d. Data d => d -> u) -> RNAensembleStructure -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> RNAensembleStructure -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RNAensembleStructure -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RNAensembleStructure -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RNAensembleStructure -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RNAensembleStructure -> r
gmapT :: (forall b. Data b => b -> b)
-> RNAensembleStructure -> RNAensembleStructure
$cgmapT :: (forall b. Data b => b -> b)
-> RNAensembleStructure -> RNAensembleStructure
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RNAensembleStructure)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RNAensembleStructure)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c RNAensembleStructure)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RNAensembleStructure)
dataTypeOf :: RNAensembleStructure -> DataType
$cdataTypeOf :: RNAensembleStructure -> DataType
toConstr :: RNAensembleStructure -> Constr
$ctoConstr :: RNAensembleStructure -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RNAensembleStructure
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RNAensembleStructure
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> RNAensembleStructure
-> c RNAensembleStructure
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> RNAensembleStructure
-> c RNAensembleStructure
$cp1Data :: Typeable RNAensembleStructure
Data,Typeable,(forall x. RNAensembleStructure -> Rep RNAensembleStructure x)
-> (forall x. Rep RNAensembleStructure x -> RNAensembleStructure)
-> Generic RNAensembleStructure
forall x. Rep RNAensembleStructure x -> RNAensembleStructure
forall x. RNAensembleStructure -> Rep RNAensembleStructure x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RNAensembleStructure x -> RNAensembleStructure
$cfrom :: forall x. RNAensembleStructure -> Rep RNAensembleStructure x
Generic)
makeLenses ''RNAensembleStructure

instance NFData RNAensembleStructure

-- | Cofolded structure.

data RNAds = RNAds
  { RNAds -> ByteString
_rnadsL ∷ !ByteString
  , RNAds -> ByteString
_rnadsR ∷ !ByteString
  }
  deriving (RNAds -> RNAds -> Bool
(RNAds -> RNAds -> Bool) -> (RNAds -> RNAds -> Bool) -> Eq RNAds
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RNAds -> RNAds -> Bool
$c/= :: RNAds -> RNAds -> Bool
== :: RNAds -> RNAds -> Bool
$c== :: RNAds -> RNAds -> Bool
Eq,Eq RNAds
Eq RNAds
-> (RNAds -> RNAds -> Ordering)
-> (RNAds -> RNAds -> Bool)
-> (RNAds -> RNAds -> Bool)
-> (RNAds -> RNAds -> Bool)
-> (RNAds -> RNAds -> Bool)
-> (RNAds -> RNAds -> RNAds)
-> (RNAds -> RNAds -> RNAds)
-> Ord RNAds
RNAds -> RNAds -> Bool
RNAds -> RNAds -> Ordering
RNAds -> RNAds -> RNAds
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 :: RNAds -> RNAds -> RNAds
$cmin :: RNAds -> RNAds -> RNAds
max :: RNAds -> RNAds -> RNAds
$cmax :: RNAds -> RNAds -> RNAds
>= :: RNAds -> RNAds -> Bool
$c>= :: RNAds -> RNAds -> Bool
> :: RNAds -> RNAds -> Bool
$c> :: RNAds -> RNAds -> Bool
<= :: RNAds -> RNAds -> Bool
$c<= :: RNAds -> RNAds -> Bool
< :: RNAds -> RNAds -> Bool
$c< :: RNAds -> RNAds -> Bool
compare :: RNAds -> RNAds -> Ordering
$ccompare :: RNAds -> RNAds -> Ordering
$cp1Ord :: Eq RNAds
Ord,Int -> RNAds -> ShowS
[RNAds] -> ShowS
RNAds -> String
(Int -> RNAds -> ShowS)
-> (RNAds -> String) -> ([RNAds] -> ShowS) -> Show RNAds
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RNAds] -> ShowS
$cshowList :: [RNAds] -> ShowS
show :: RNAds -> String
$cshow :: RNAds -> String
showsPrec :: Int -> RNAds -> ShowS
$cshowsPrec :: Int -> RNAds -> ShowS
Show,ReadPrec [RNAds]
ReadPrec RNAds
Int -> ReadS RNAds
ReadS [RNAds]
(Int -> ReadS RNAds)
-> ReadS [RNAds]
-> ReadPrec RNAds
-> ReadPrec [RNAds]
-> Read RNAds
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RNAds]
$creadListPrec :: ReadPrec [RNAds]
readPrec :: ReadPrec RNAds
$creadPrec :: ReadPrec RNAds
readList :: ReadS [RNAds]
$creadList :: ReadS [RNAds]
readsPrec :: Int -> ReadS RNAds
$creadsPrec :: Int -> ReadS RNAds
Read,Typeable RNAds
DataType
Constr
Typeable RNAds
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RNAds -> c RNAds)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RNAds)
-> (RNAds -> Constr)
-> (RNAds -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RNAds))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RNAds))
-> ((forall b. Data b => b -> b) -> RNAds -> RNAds)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RNAds -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RNAds -> r)
-> (forall u. (forall d. Data d => d -> u) -> RNAds -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RNAds -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RNAds -> m RNAds)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RNAds -> m RNAds)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RNAds -> m RNAds)
-> Data RNAds
RNAds -> DataType
RNAds -> Constr
(forall b. Data b => b -> b) -> RNAds -> RNAds
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RNAds -> c RNAds
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RNAds
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RNAds -> u
forall u. (forall d. Data d => d -> u) -> RNAds -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RNAds -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RNAds -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RNAds -> m RNAds
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RNAds -> m RNAds
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RNAds
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RNAds -> c RNAds
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RNAds)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RNAds)
$cRNAds :: Constr
$tRNAds :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> RNAds -> m RNAds
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RNAds -> m RNAds
gmapMp :: (forall d. Data d => d -> m d) -> RNAds -> m RNAds
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RNAds -> m RNAds
gmapM :: (forall d. Data d => d -> m d) -> RNAds -> m RNAds
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RNAds -> m RNAds
gmapQi :: Int -> (forall d. Data d => d -> u) -> RNAds -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RNAds -> u
gmapQ :: (forall d. Data d => d -> u) -> RNAds -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RNAds -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RNAds -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RNAds -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RNAds -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RNAds -> r
gmapT :: (forall b. Data b => b -> b) -> RNAds -> RNAds
$cgmapT :: (forall b. Data b => b -> b) -> RNAds -> RNAds
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RNAds)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RNAds)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c RNAds)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RNAds)
dataTypeOf :: RNAds -> DataType
$cdataTypeOf :: RNAds -> DataType
toConstr :: RNAds -> Constr
$ctoConstr :: RNAds -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RNAds
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RNAds
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RNAds -> c RNAds
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RNAds -> c RNAds
$cp1Data :: Typeable RNAds
Data,Typeable,(forall x. RNAds -> Rep RNAds x)
-> (forall x. Rep RNAds x -> RNAds) -> Generic RNAds
forall x. Rep RNAds x -> RNAds
forall x. RNAds -> Rep RNAds x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RNAds x -> RNAds
$cfrom :: forall x. RNAds -> Rep RNAds x
Generic)
makeLenses ''RNAds

instance NFData RNAds

-- | A Prism that turns ByteStrings with a single @&@ into @RNAds@.

rnads ∷ Prism' ByteString RNAds
rnads :: p RNAds (f RNAds) -> p ByteString (f ByteString)
rnads = (RNAds -> ByteString)
-> (ByteString -> Either ByteString RNAds)
-> Prism ByteString ByteString RNAds RNAds
forall b t s a. (b -> t) -> (s -> Either t a) -> Prism s t a b
prism (\(RNAds ByteString
l ByteString
r) → [ByteString] -> ByteString
BS8.concat [ByteString
l, ByteString
"&", ByteString
r])
              (\ByteString
s → case Char -> ByteString -> [ByteString]
BS8.split Char
'&' ByteString
s of [ByteString
l,ByteString
r] → RNAds -> Either ByteString RNAds
forall a b. b -> Either a b
Right (ByteString -> ByteString -> RNAds
RNAds ByteString
l ByteString
r) ; [ByteString]
_ → ByteString -> Either ByteString RNAds
forall a b. a -> Either a b
Left ByteString
s)
{-# Inline rnads #-}

-- | Isomorphism from @RNAds@ to @(RNAss,RNAss)@. The @RNAss@ are only
-- legal if taken both: @rnassFromDimer . both@.

rnads2rnassPair ∷ Iso' RNAds (RNAss, RNAss)
rnads2rnassPair :: p (RNAss, RNAss) (f (RNAss, RNAss)) -> p RNAds (f RNAds)
rnads2rnassPair = (RNAds -> (RNAss, RNAss))
-> ((RNAss, RNAss) -> RNAds)
-> Iso RNAds RNAds (RNAss, RNAss) (RNAss, RNAss)
forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso (\(RNAds ByteString
l ByteString
r) → (ByteString -> RNAss
RNAss ByteString
l, ByteString -> RNAss
RNAss ByteString
r)) (\(RNAss ByteString
l, RNAss ByteString
r) → ByteString -> ByteString -> RNAds
RNAds ByteString
l ByteString
r)
{-# Inline rnads2rnassPair #-}

-- | Try to create a dimeric structure.

mkRNAds ∷ (Monad m, MonadError RNAStructureError m) ⇒ ByteString → m RNAds
mkRNAds :: ByteString -> m RNAds
mkRNAds ByteString
q = Char -> ByteString -> [ByteString]
BS8.split Char
'&' ByteString
q [ByteString] -> ([ByteString] -> m RNAds) -> m RNAds
forall a b. a -> (a -> b) -> b
& \case
    [ByteString
l,ByteString
r] → do
      -- TODO can still fail with unmatched brackets.
      RNAds -> m RNAds
forall (m :: * -> *) a. Monad m => a -> m a
return (RNAds -> m RNAds) -> RNAds -> m RNAds
forall a b. (a -> b) -> a -> b
$ RNAds :: ByteString -> ByteString -> RNAds
RNAds
        { _rnadsL :: ByteString
_rnadsL = ByteString
l
        , _rnadsR :: ByteString
_rnadsR = ByteString
r
        }
    [ByteString]
_     → RNAStructureError -> m RNAds
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RNAStructureError -> m RNAds) -> RNAStructureError -> m RNAds
forall a b. (a -> b) -> a -> b
$ String -> ByteString -> RNAStructureError
RNAStructureError String
"mkRNAds: not a dimer" ByteString
q
{-# Inline mkRNAds #-}

-- | Capture what might be wrong with the RNAss.

data RNAStructureError = RNAStructureError
  { RNAStructureError -> String
_rnaStructureError  ∷ String
  , RNAStructureError -> ByteString
_rnaOffender        ∷ ByteString
  }
  deriving (Int -> RNAStructureError -> ShowS
[RNAStructureError] -> ShowS
RNAStructureError -> String
(Int -> RNAStructureError -> ShowS)
-> (RNAStructureError -> String)
-> ([RNAStructureError] -> ShowS)
-> Show RNAStructureError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RNAStructureError] -> ShowS
$cshowList :: [RNAStructureError] -> ShowS
show :: RNAStructureError -> String
$cshow :: RNAStructureError -> String
showsPrec :: Int -> RNAStructureError -> ShowS
$cshowsPrec :: Int -> RNAStructureError -> ShowS
Show,(forall x. RNAStructureError -> Rep RNAStructureError x)
-> (forall x. Rep RNAStructureError x -> RNAStructureError)
-> Generic RNAStructureError
forall x. Rep RNAStructureError x -> RNAStructureError
forall x. RNAStructureError -> Rep RNAStructureError x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RNAStructureError x -> RNAStructureError
$cfrom :: forall x. RNAStructureError -> Rep RNAStructureError x
Generic)

instance NFData RNAStructureError

-- | Verifies that the given RNAss is properly formatted. Otherwise, error out.
--
-- TODO Implement! Check with BiobaseXNA and the stack effort in there. This
-- might influence if the verification goes into BiobaseXNA and happens via an
-- @Iso'@.

verifyRNAss ∷ (Monad m, MonadError RNAStructureError m) ⇒ RNAss → m RNAss
verifyRNAss :: RNAss -> m RNAss
verifyRNAss RNAss
ss = do
  RNAss -> m RNAss
forall (m :: * -> *) a. Monad m => a -> m a
return RNAss
ss

-- | The set of nucleotide pairs, together with the sequence length.

data RNApset = RNApset
  { RNApset -> Set (Int, Int)
_rnapset      ∷ !(Set (Int,Int))
    -- ^ the set of nucleotide pairs.
  , RNApset -> Int
_rnapsetSLen  ∷ !Int
    -- ^ length of the underlying nucleotide sequence.
  }
  deriving (ReadPrec [RNApset]
ReadPrec RNApset
Int -> ReadS RNApset
ReadS [RNApset]
(Int -> ReadS RNApset)
-> ReadS [RNApset]
-> ReadPrec RNApset
-> ReadPrec [RNApset]
-> Read RNApset
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RNApset]
$creadListPrec :: ReadPrec [RNApset]
readPrec :: ReadPrec RNApset
$creadPrec :: ReadPrec RNApset
readList :: ReadS [RNApset]
$creadList :: ReadS [RNApset]
readsPrec :: Int -> ReadS RNApset
$creadsPrec :: Int -> ReadS RNApset
Read,Int -> RNApset -> ShowS
[RNApset] -> ShowS
RNApset -> String
(Int -> RNApset -> ShowS)
-> (RNApset -> String) -> ([RNApset] -> ShowS) -> Show RNApset
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RNApset] -> ShowS
$cshowList :: [RNApset] -> ShowS
show :: RNApset -> String
$cshow :: RNApset -> String
showsPrec :: Int -> RNApset -> ShowS
$cshowsPrec :: Int -> RNApset -> ShowS
Show,RNApset -> RNApset -> Bool
(RNApset -> RNApset -> Bool)
-> (RNApset -> RNApset -> Bool) -> Eq RNApset
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RNApset -> RNApset -> Bool
$c/= :: RNApset -> RNApset -> Bool
== :: RNApset -> RNApset -> Bool
$c== :: RNApset -> RNApset -> Bool
Eq,Eq RNApset
Eq RNApset
-> (RNApset -> RNApset -> Ordering)
-> (RNApset -> RNApset -> Bool)
-> (RNApset -> RNApset -> Bool)
-> (RNApset -> RNApset -> Bool)
-> (RNApset -> RNApset -> Bool)
-> (RNApset -> RNApset -> RNApset)
-> (RNApset -> RNApset -> RNApset)
-> Ord RNApset
RNApset -> RNApset -> Bool
RNApset -> RNApset -> Ordering
RNApset -> RNApset -> RNApset
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 :: RNApset -> RNApset -> RNApset
$cmin :: RNApset -> RNApset -> RNApset
max :: RNApset -> RNApset -> RNApset
$cmax :: RNApset -> RNApset -> RNApset
>= :: RNApset -> RNApset -> Bool
$c>= :: RNApset -> RNApset -> Bool
> :: RNApset -> RNApset -> Bool
$c> :: RNApset -> RNApset -> Bool
<= :: RNApset -> RNApset -> Bool
$c<= :: RNApset -> RNApset -> Bool
< :: RNApset -> RNApset -> Bool
$c< :: RNApset -> RNApset -> Bool
compare :: RNApset -> RNApset -> Ordering
$ccompare :: RNApset -> RNApset -> Ordering
$cp1Ord :: Eq RNApset
Ord,(forall x. RNApset -> Rep RNApset x)
-> (forall x. Rep RNApset x -> RNApset) -> Generic RNApset
forall x. Rep RNApset x -> RNApset
forall x. RNApset -> Rep RNApset x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RNApset x -> RNApset
$cfrom :: forall x. RNApset -> Rep RNApset x
Generic)
makeLenses ''RNApset

instance NFData RNApset

-- | Transform an 'RNAss' into a set of base pairs @(i,j)@. The pairs are
-- 0-based.

rnassPairSet
  ∷ (MonadError String m)
  ⇒ RNAss
  → m RNApset
rnassPairSet :: RNAss -> m RNApset
rnassPairSet (RNAss ByteString
s2) = do
  let go :: (Set (Int, Int), [Int]) -> (Int, Char) -> m (Set (Int, Int), [Int])
go (Set (Int, Int)
set,[Int]
ks  ) (Int
i,Char
'(') = (Set (Int, Int), [Int]) -> m (Set (Int, Int), [Int])
forall (m :: * -> *) a. Monad m => a -> m a
return (Set (Int, Int)
set,Int
iInt -> [Int] -> [Int]
forall a. a -> [a] -> [a]
:[Int]
ks)
      go (Set (Int, Int)
set,Int
i:[Int]
is) (Int
j,Char
')') = (Set (Int, Int), [Int]) -> m (Set (Int, Int), [Int])
forall (m :: * -> *) a. Monad m => a -> m a
return ((Int, Int) -> Set (Int, Int) -> Set (Int, Int)
forall a. Ord a => a -> Set a -> Set a
Set.insert (Int
i,Int
j) Set (Int, Int)
set, [Int]
is)
      go (Set (Int, Int)
set,[]  ) (Int
j,Char
')') = String -> m (Set (Int, Int), [Int])
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (String -> m (Set (Int, Int), [Int]))
-> String -> m (Set (Int, Int), [Int])
forall a b. (a -> b) -> a -> b
$ String
"unequal brackets in \"" String -> ShowS
forall a. [a] -> [a] -> [a]
++ ByteString -> String
BS8.unpack ByteString
s2 String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"\" at position: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
j
      go (Set (Int, Int)
set,[Int]
ks  ) (Int
_,Char
'.') = (Set (Int, Int), [Int]) -> m (Set (Int, Int), [Int])
forall (m :: * -> *) a. Monad m => a -> m a
return (Set (Int, Int)
set,[Int]
ks)
  (Set (Int, Int)
set,[Int]
ss) ← ((Set (Int, Int), [Int])
 -> (Int, Char) -> m (Set (Int, Int), [Int]))
-> (Set (Int, Int), [Int])
-> [(Int, Char)]
-> m (Set (Int, Int), [Int])
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM (Set (Int, Int), [Int]) -> (Int, Char) -> m (Set (Int, Int), [Int])
go (Set (Int, Int)
forall a. Set a
Set.empty,[]) ([(Int, Char)] -> m (Set (Int, Int), [Int]))
-> (String -> [(Int, Char)]) -> String -> m (Set (Int, Int), [Int])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Int] -> String -> [(Int, Char)]
forall a b. [a] -> [b] -> [(a, b)]
L.zip [Int
0..] (String -> m (Set (Int, Int), [Int]))
-> String -> m (Set (Int, Int), [Int])
forall a b. (a -> b) -> a -> b
$ ByteString -> String
BS8.unpack ByteString
s2
  Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless ([Int] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Int]
ss) (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ String -> m ()
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (String -> m ()) -> String -> m ()
forall a b. (a -> b) -> a -> b
$ String
"unequal brackets in \"" String -> ShowS
forall a. [a] -> [a] -> [a]
++ ByteString -> String
BS8.unpack ByteString
s2 String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"\" with opening bracket(s): " String -> ShowS
forall a. [a] -> [a] -> [a]
++ [Int] -> String
forall a. Show a => a -> String
show [Int]
ss
  RNApset -> m RNApset
forall (m :: * -> *) a. Monad m => a -> m a
return (RNApset -> m RNApset) -> RNApset -> m RNApset
forall a b. (a -> b) -> a -> b
$ Set (Int, Int) -> Int -> RNApset
RNApset Set (Int, Int)
set (ByteString -> Int
BS8.length ByteString
s2)
{-# Inlinable rnassPairSet #-}

-- | Genereate a simple structured/paired forest from a secondary structure string.

rnassSPForest
  ∷ (MonadError String m)
  ⇒ RNAss
  → m (SPForest ByteString Char)
rnassSPForest :: RNAss -> m (SPForest ByteString Char)
rnassSPForest (RNAss ByteString
s2) = (String -> m (SPForest ByteString Char))
-> (SPForest ByteString Char -> m (SPForest ByteString Char))
-> Either String (SPForest ByteString Char)
-> m (SPForest ByteString Char)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either String -> m (SPForest ByteString Char)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError SPForest ByteString Char -> m (SPForest ByteString Char)
forall (m :: * -> *) a. Monad m => a -> m a
return (Either String (SPForest ByteString Char)
 -> m (SPForest ByteString Char))
-> Either String (SPForest ByteString Char)
-> m (SPForest ByteString Char)
forall a b. (a -> b) -> a -> b
$ Parser (SPForest ByteString Char)
-> ByteString -> Either String (SPForest ByteString Char)
forall a. Parser a -> ByteString -> Either String a
parseOnly (Parser (SPForest ByteString Char)
manyElems Parser (SPForest ByteString Char)
-> Parser ByteString () -> Parser (SPForest ByteString Char)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser ByteString ()
forall t. Chunk t => Parser t ()
endOfInput) ByteString
s2
  where
    tree :: Parser (SPForest ByteString Char)
tree = Char
-> SPForest ByteString Char -> Char -> SPForest ByteString Char
forall r t. t -> SPForest r t -> t -> SPForest r t
SPT (Char
 -> SPForest ByteString Char -> Char -> SPForest ByteString Char)
-> Parser ByteString Char
-> Parser
     ByteString
     (SPForest ByteString Char -> Char -> SPForest ByteString Char)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Char -> Parser ByteString Char
char Char
'(' Parser
  ByteString
  (SPForest ByteString Char -> Char -> SPForest ByteString Char)
-> Parser (SPForest ByteString Char)
-> Parser ByteString (Char -> SPForest ByteString Char)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (SPForest ByteString Char)
someElems Parser ByteString (Char -> SPForest ByteString Char)
-> Parser ByteString Char -> Parser (SPForest ByteString Char)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Char -> Parser ByteString Char
char Char
')' Parser (SPForest ByteString Char)
-> String -> Parser (SPForest ByteString Char)
forall i a. Parser i a -> String -> Parser i a
<?> String
"SPT"
    unpaired :: Parser ByteString (SPForest ByteString t)
unpaired  = ByteString -> SPForest ByteString t
forall r t. r -> SPForest r t
SPR (ByteString -> SPForest ByteString t)
-> Parser ByteString ByteString
-> Parser ByteString (SPForest ByteString t)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Char -> Bool) -> Parser ByteString ByteString
takeWhile1 (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==Char
'.') Parser ByteString (SPForest ByteString t)
-> String -> Parser ByteString (SPForest ByteString t)
forall i a. Parser i a -> String -> Parser i a
<?> String
"SPR"
    someElems :: Parser (SPForest ByteString Char)
someElems = [SPForest ByteString Char] -> SPForest ByteString Char
forall r t. [SPForest r t] -> SPForest r t
SPJ ([SPForest ByteString Char] -> SPForest ByteString Char)
-> Parser ByteString [SPForest ByteString Char]
-> Parser (SPForest ByteString Char)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (SPForest ByteString Char)
-> Parser ByteString [SPForest ByteString Char]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many1 (Parser (SPForest ByteString Char)
tree Parser (SPForest ByteString Char)
-> Parser (SPForest ByteString Char)
-> Parser (SPForest ByteString Char)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (SPForest ByteString Char)
forall t. Parser ByteString (SPForest ByteString t)
unpaired) Parser (SPForest ByteString Char)
-> String -> Parser (SPForest ByteString Char)
forall i a. Parser i a -> String -> Parser i a
<?> String
"many1 SPT / SPR"
    manyElems :: Parser (SPForest ByteString Char)
manyElems = (\case {[] → SPForest ByteString Char
forall r t. SPForest r t
SPE; [SPForest ByteString Char]
xs → [SPForest ByteString Char] -> SPForest ByteString Char
forall r t. [SPForest r t] -> SPForest r t
SPJ [SPForest ByteString Char]
xs}) ([SPForest ByteString Char] -> SPForest ByteString Char)
-> Parser ByteString [SPForest ByteString Char]
-> Parser (SPForest ByteString Char)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (SPForest ByteString Char)
-> Parser ByteString [SPForest ByteString Char]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many  (Parser (SPForest ByteString Char)
tree Parser (SPForest ByteString Char)
-> Parser (SPForest ByteString Char)
-> Parser (SPForest ByteString Char)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (SPForest ByteString Char)
forall t. Parser ByteString (SPForest ByteString t)
unpaired) Parser (SPForest ByteString Char)
-> String -> Parser (SPForest ByteString Char)
forall i a. Parser i a -> String -> Parser i a
<?> String
"many0 SPT / SPR"
{-# Inlinable rnassSPForest #-}

-- | Compactify such an SPForest. This means that all stems are now represented
-- by a single 'SPT' data constructor.

compactifySPForest
  ∷ SPForest ByteString Char
  → SPForest ByteString ByteString
compactifySPForest :: SPForest ByteString Char -> SPForest ByteString ByteString
compactifySPForest = SPForest ByteString ByteString -> SPForest ByteString ByteString
forall t r. Semigroup t => SPForest r t -> SPForest r t
go (SPForest ByteString ByteString -> SPForest ByteString ByteString)
-> (SPForest ByteString Char -> SPForest ByteString ByteString)
-> SPForest ByteString Char
-> SPForest ByteString ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> ByteString)
-> SPForest ByteString Char -> SPForest ByteString ByteString
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second Char -> ByteString
BS8.singleton
  where go :: SPForest r t -> SPForest r t
go SPForest r t
SPE      = SPForest r t
forall r t. SPForest r t
SPE
        go (SPR r
x)  = r -> SPForest r t
forall r t. r -> SPForest r t
SPR r
x
        go (SPJ [SPForest r t]
xs) = [SPForest r t] -> SPForest r t
forall r t. [SPForest r t] -> SPForest r t
SPJ ((SPForest r t -> SPForest r t) -> [SPForest r t] -> [SPForest r t]
forall a b. (a -> b) -> [a] -> [b]
map SPForest r t -> SPForest r t
go [SPForest r t]
xs)
        go (SPT t
l (SPJ [SPForest r t
x]) t
r) = SPForest r t -> SPForest r t
go (SPForest r t -> SPForest r t) -> SPForest r t -> SPForest r t
forall a b. (a -> b) -> a -> b
$ t -> SPForest r t -> t -> SPForest r t
forall r t. t -> SPForest r t -> t -> SPForest r t
SPT t
l SPForest r t
x t
r
        go (SPT t
l (SPT t
l' SPForest r t
t t
r') t
r) = SPForest r t -> SPForest r t
go (SPForest r t -> SPForest r t) -> SPForest r t -> SPForest r t
forall a b. (a -> b) -> a -> b
$ t -> SPForest r t -> t -> SPForest r t
forall r t. t -> SPForest r t -> t -> SPForest r t
SPT (t
l t -> t -> t
forall a. Semigroup a => a -> a -> a
<> t
l') SPForest r t
t (t
r' t -> t -> t
forall a. Semigroup a => a -> a -> a
<> t
r)
        go (SPT t
l SPForest r t
t             t
r) = t -> SPForest r t -> t -> SPForest r t
forall r t. t -> SPForest r t -> t -> SPForest r t
SPT t
l (SPForest r t -> SPForest r t
go SPForest r t
t) t
r

-- | RNA pair set, but a transformation error calls @error@.

rnassPairSet' ∷ RNAss → RNApset
rnassPairSet' :: RNAss -> RNApset
rnassPairSet' = (String -> RNApset)
-> (RNApset -> RNApset) -> Either String RNApset -> RNApset
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either String -> RNApset
forall a. HasCallStack => String -> a
error RNApset -> RNApset
forall a. a -> a
id (Either String RNApset -> RNApset)
-> (RNAss -> Either String RNApset) -> RNAss -> RNApset
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RNAss -> Either String RNApset
forall (m :: * -> *). MonadError String m => RNAss -> m RNApset
rnassPairSet

rnapsetRNAss ∷ RNApset → RNAss
rnapsetRNAss :: RNApset -> RNAss
rnapsetRNAss (RNApset Set (Int, Int)
ps Int
l) = ByteString -> RNAss
RNAss (ByteString -> RNAss) -> ByteString -> RNAss
forall a b. (a -> b) -> a -> b
$ String -> ByteString
BS8.pack (String -> ByteString) -> String -> ByteString
forall a b. (a -> b) -> a -> b
$ Vector Char -> String
forall a. Unbox a => Vector a -> [a]
VU.toList Vector Char
xs
  where xs :: Vector Char
xs = Int -> Char -> Vector Char
forall a. Unbox a => Int -> a -> Vector a
VU.replicate Int
l Char
'.' Vector Char -> [(Int, Char)] -> Vector Char
forall a. Unbox a => Vector a -> [(Int, a)] -> Vector a
VU.// [(Int, Char)]
ls Vector Char -> [(Int, Char)] -> Vector Char
forall a. Unbox a => Vector a -> [(Int, a)] -> Vector a
VU.// [(Int, Char)]
rs
        ls :: [(Int, Char)]
ls = ((Int, Int) -> (Int, Char)) -> [(Int, Int)] -> [(Int, Char)]
forall a b. (a -> b) -> [a] -> [b]
L.map ((,Char
'(') (Int -> (Int, Char))
-> ((Int, Int) -> Int) -> (Int, Int) -> (Int, Char)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int, Int) -> Int
forall a b. (a, b) -> a
fst) ([(Int, Int)] -> [(Int, Char)]) -> [(Int, Int)] -> [(Int, Char)]
forall a b. (a -> b) -> a -> b
$ Set (Int, Int) -> [(Int, Int)]
forall a. Set a -> [a]
S.toList Set (Int, Int)
ps
        rs :: [(Int, Char)]
rs = ((Int, Int) -> (Int, Char)) -> [(Int, Int)] -> [(Int, Char)]
forall a b. (a -> b) -> [a] -> [b]
L.map ((,Char
')') (Int -> (Int, Char))
-> ((Int, Int) -> Int) -> (Int, Int) -> (Int, Char)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int, Int) -> Int
forall a b. (a, b) -> b
snd) ([(Int, Int)] -> [(Int, Char)]) -> [(Int, Int)] -> [(Int, Char)]
forall a b. (a -> b) -> a -> b
$ Set (Int, Int) -> [(Int, Int)]
forall a. Set a -> [a]
S.toList Set (Int, Int)
ps

-- | Calculates the number of different base pairs between two structures. This
-- ignores the length of the underlying sequences.

pairDist ∷ RNApset → RNApset → Int
pairDist :: RNApset -> RNApset -> Int
pairDist (RNApset Set (Int, Int)
p1 Int
_) (RNApset Set (Int, Int)
p2 Int
_) = Set (Int, Int) -> Int
forall a. Set a -> Int
Set.size Set (Int, Int)
z1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Set (Int, Int) -> Int
forall a. Set a -> Int
Set.size Set (Int, Int)
z2
  where i :: Set (Int, Int)
i = Set (Int, Int) -> Set (Int, Int) -> Set (Int, Int)
forall a. Ord a => Set a -> Set a -> Set a
Set.intersection Set (Int, Int)
p1 Set (Int, Int)
p2
        z1 :: Set (Int, Int)
z1 = Set (Int, Int)
p1 Set (Int, Int) -> Set (Int, Int) -> Set (Int, Int)
forall a. Ord a => Set a -> Set a -> Set a
`Set.difference` Set (Int, Int)
i
        z2 :: Set (Int, Int)
z2 = Set (Int, Int)
p2 Set (Int, Int) -> Set (Int, Int) -> Set (Int, Int)
forall a. Ord a => Set a -> Set a -> Set a
`Set.difference` Set (Int, Int)
i



-- * Arbitrary instances. This only creates legal instances, but does *not*
-- take into account ViennaRNA rules like three unpaired nucleotides in the
-- hairpin.
--
-- TODO @shrink@ is a bit more complicated, but can be done via a set of pairs.

instance Q.Arbitrary RNApset where
  arbitrary :: Gen RNApset
arbitrary = do
    -- Given left and right bounds, create pairs.
    let go ∷ Int → Int → Q.Gen (Set (Int,Int))
        go :: Int -> Int -> Gen (Set (Int, Int))
go Int
l Int
r
          | Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
r    = Set (Int, Int) -> Gen (Set (Int, Int))
forall (m :: * -> *) a. Monad m => a -> m a
return Set (Int, Int)
forall a. Set a
S.empty
          | Bool
otherwise = do
            -- right border of stack
            Int
c ∷ Int ← [Gen Int] -> Gen Int
forall a. [Gen a] -> Gen a
Q.oneof [ (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
Q.choose (Int
lInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1,Int
r)  -- wide jump
                              , (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
Q.choose (Int
lInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1, Int -> Int -> Int
forall a. Ord a => a -> a -> a
min Int
r (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ Int
lInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
20)  -- short jump
                              ]
            -- with @1..10@ stack length
            Int
z ∷ Int ← (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
Q.choose (Int
0,Int
5)
            let stack :: Set (Int, Int)
stack = [(Int, Int)] -> Set (Int, Int)
forall a. Ord a => [a] -> Set a
S.fromList [(Int
lInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
k,Int
cInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
k) | Int
k ← [Int
0..Int
zInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1], Int
lInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
kInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
cInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
k]
            Set (Int, Int)
right ← Int -> Int -> Gen (Set (Int, Int))
go (Int
cInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) Int
r
            Set (Int, Int) -> Gen (Set (Int, Int))
forall (m :: * -> *) a. Monad m => a -> m a
return (Set (Int, Int) -> Gen (Set (Int, Int)))
-> Set (Int, Int) -> Gen (Set (Int, Int))
forall a b. (a -> b) -> a -> b
$ Set (Int, Int) -> Set (Int, Int) -> Set (Int, Int)
forall a. Ord a => Set a -> Set a -> Set a
S.union Set (Int, Int)
stack Set (Int, Int)
right
    -- generate RNA structures between 0 and 100 nucleotides.
    Int
l ∷ Int ← (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
Q.choose (Int
0,Int
199)
    Set (Int, Int)
s ← Int -> Int -> Gen (Set (Int, Int))
go Int
0 Int
l
    RNApset -> Gen RNApset
forall (m :: * -> *) a. Monad m => a -> m a
return (RNApset -> Gen RNApset) -> RNApset -> Gen RNApset
forall a b. (a -> b) -> a -> b
$ Set (Int, Int) -> Int -> RNApset
RNApset Set (Int, Int)
s (Int
lInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)

instance Q.Arbitrary RNAss where
  arbitrary :: Gen RNAss
arbitrary = RNApset -> RNAss
rnapsetRNAss (RNApset -> RNAss) -> Gen RNApset -> Gen RNAss
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen RNApset
forall a. Arbitrary a => Gen a
Q.arbitrary