Biobase.Primary.Letter

A newtype with an attached phenotype which allows us to encode nucleotides and amino acids. Actual seqence-specific functions can be founds in the appropriate modules AA and Nuc.

Documentation

newtype Letter t

A Letter together with its phantom type t encodes bio-sequences.

Constructors

Letter

Fields

• getLetter :: Int

Instances

IsostericityLookup ExtPair

For extended basepairs, we take the default mapping and go from there.

TODO inClass missing

Methods

getClasses :: ExtPair -> [String]

inClass :: String -> [ExtPair]

IsostericityLookup Pair

Normal basepairs are assumed to have cWW basepairing.

TODO inClass missing

Methods

getClasses :: Pair -> [String]

inClass :: String -> [Pair]

Vector Vector (Letter k a0)

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Letter k a0) -> m (Vector (Letter k a0))

basicUnsafeThaw :: PrimMonad m => Vector (Letter k a0) -> m (Mutable Vector (PrimState m) (Letter k a0))

basicLength :: Vector (Letter k a0) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Letter k a0) -> Vector (Letter k a0)

basicUnsafeIndexM :: Monad m => Vector (Letter k a0) -> Int -> m (Letter k a0)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Letter k a0) -> Vector (Letter k a0) -> m ()

elemseq :: Vector (Letter k a0) -> Letter k a0 -> b -> b

MVector MVector (Letter k a0)

Methods

basicLength :: MVector s (Letter k a0) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Letter k a0) -> MVector s (Letter k a0)

basicOverlaps :: MVector s (Letter k a0) -> MVector s (Letter k a0) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Letter k a0))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Letter k a0) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Letter k a0 -> m (MVector (PrimState m) (Letter k a0))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Letter k a0) -> Int -> m (Letter k a0)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Letter k a0) -> Int -> Letter k a0 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Letter k a0) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Letter k a0) -> Letter k a0 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Letter k a0) -> MVector (PrimState m) (Letter k a0) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Letter k a0) -> MVector (PrimState m) (Letter k a0) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Letter k a0) -> Int -> m (MVector (PrimState m) (Letter k a0))

BasepairConvert ViennaPair (Letter * RNA, Letter * RNA)

Methods

basepairConvert :: ViennaPair -> (Letter * RNA, Letter * RNA)

BasepairConvert Basepair (Letter * RNA, Letter * RNA)

Methods

basepairConvert :: Basepair -> (Letter * RNA, Letter * RNA)

IsString [Letter * DNA]

Methods

fromString :: String -> [Letter * DNA]

IsString [Letter * RNA]

Methods

fromString :: String -> [Letter * RNA]

IsString [Letter * XNA]

Methods

fromString :: String -> [Letter * XNA]

IsString [Letter * DEG]

Methods

fromString :: String -> [Letter * DEG]

(Unbox (Letter k t), IsString [Letter k t]) => IsString (Vector (Letter k t))

Methods

fromString :: String -> Vector (Letter k t)

Bounded (Letter * DNA)

Methods

minBound :: Letter * DNA

maxBound :: Letter * DNA

Bounded (Letter * RNA)

Methods

minBound :: Letter * RNA

maxBound :: Letter * RNA

Bounded (Letter * XNA)

Methods

minBound :: Letter * XNA

maxBound :: Letter * XNA

Bounded (Letter * DEG)

Methods

minBound :: Letter * DEG

maxBound :: Letter * DEG

Enum (Letter * Unknown)

Methods

succ :: Letter * Unknown -> Letter * Unknown

pred :: Letter * Unknown -> Letter * Unknown

toEnum :: Int -> Letter * Unknown

fromEnum :: Letter * Unknown -> Int

enumFrom :: Letter * Unknown -> [Letter * Unknown]

enumFromThen :: Letter * Unknown -> Letter * Unknown -> [Letter * Unknown]

enumFromTo :: Letter * Unknown -> Letter * Unknown -> [Letter * Unknown]

enumFromThenTo :: Letter * Unknown -> Letter * Unknown -> Letter * Unknown -> [Letter * Unknown]

Enum (Letter * DNA)

Methods

succ :: Letter * DNA -> Letter * DNA

pred :: Letter * DNA -> Letter * DNA

toEnum :: Int -> Letter * DNA

fromEnum :: Letter * DNA -> Int

enumFrom :: Letter * DNA -> [Letter * DNA]

enumFromThen :: Letter * DNA -> Letter * DNA -> [Letter * DNA]

enumFromTo :: Letter * DNA -> Letter * DNA -> [Letter * DNA]

enumFromThenTo :: Letter * DNA -> Letter * DNA -> Letter * DNA -> [Letter * DNA]

Enum (Letter * RNA)

Methods

succ :: Letter * RNA -> Letter * RNA

pred :: Letter * RNA -> Letter * RNA

toEnum :: Int -> Letter * RNA

fromEnum :: Letter * RNA -> Int

enumFrom :: Letter * RNA -> [Letter * RNA]

enumFromThen :: Letter * RNA -> Letter * RNA -> [Letter * RNA]

enumFromTo :: Letter * RNA -> Letter * RNA -> [Letter * RNA]

enumFromThenTo :: Letter * RNA -> Letter * RNA -> Letter * RNA -> [Letter * RNA]

Enum (Letter * XNA)

Methods

succ :: Letter * XNA -> Letter * XNA

pred :: Letter * XNA -> Letter * XNA

toEnum :: Int -> Letter * XNA

fromEnum :: Letter * XNA -> Int

enumFrom :: Letter * XNA -> [Letter * XNA]

enumFromThen :: Letter * XNA -> Letter * XNA -> [Letter * XNA]

enumFromTo :: Letter * XNA -> Letter * XNA -> [Letter * XNA]

enumFromThenTo :: Letter * XNA -> Letter * XNA -> Letter * XNA -> [Letter * XNA]

Enum (Letter * DEG)

Methods

succ :: Letter * DEG -> Letter * DEG

pred :: Letter * DEG -> Letter * DEG

toEnum :: Int -> Letter * DEG

fromEnum :: Letter * DEG -> Int

enumFrom :: Letter * DEG -> [Letter * DEG]

enumFromThen :: Letter * DEG -> Letter * DEG -> [Letter * DEG]

enumFromTo :: Letter * DEG -> Letter * DEG -> [Letter * DEG]

enumFromThenTo :: Letter * DEG -> Letter * DEG -> Letter * DEG -> [Letter * DEG]

Enum (Letter * AA)

Methods

succ :: Letter * AA -> Letter * AA

pred :: Letter * AA -> Letter * AA

toEnum :: Int -> Letter * AA

fromEnum :: Letter * AA -> Int

enumFrom :: Letter * AA -> [Letter * AA]

enumFromThen :: Letter * AA -> Letter * AA -> [Letter * AA]

enumFromTo :: Letter * AA -> Letter * AA -> [Letter * AA]

enumFromThenTo :: Letter * AA -> Letter * AA -> Letter * AA -> [Letter * AA]

Eq (Letter k t)

Methods

(==) :: Letter k t -> Letter k t -> Bool

(/=) :: Letter k t -> Letter k t -> Bool

Ord (Letter k t)

Methods

compare :: Letter k t -> Letter k t -> Ordering

(<) :: Letter k t -> Letter k t -> Bool

(<=) :: Letter k t -> Letter k t -> Bool

(>) :: Letter k t -> Letter k t -> Bool

(>=) :: Letter k t -> Letter k t -> Bool

max :: Letter k t -> Letter k t -> Letter k t

min :: Letter k t -> Letter k t -> Letter k t

Read (Letter * Unknown)

Methods

readsPrec :: Int -> ReadS (Letter * Unknown)

readList :: ReadS [Letter * Unknown]

readPrec :: ReadPrec (Letter * Unknown)

readListPrec :: ReadPrec [Letter * Unknown]

Read (Letter * DNA)

Methods

readsPrec :: Int -> ReadS (Letter * DNA)

readList :: ReadS [Letter * DNA]

readPrec :: ReadPrec (Letter * DNA)

readListPrec :: ReadPrec [Letter * DNA]

Read (Letter * RNA)

Methods

readsPrec :: Int -> ReadS (Letter * RNA)

readList :: ReadS [Letter * RNA]

readPrec :: ReadPrec (Letter * RNA)

readListPrec :: ReadPrec [Letter * RNA]

Read (Letter * XNA)

Methods

readsPrec :: Int -> ReadS (Letter * XNA)

readList :: ReadS [Letter * XNA]

readPrec :: ReadPrec (Letter * XNA)

readListPrec :: ReadPrec [Letter * XNA]

Read (Letter * AA)

Methods

readsPrec :: Int -> ReadS (Letter * AA)

readList :: ReadS [Letter * AA]

readPrec :: ReadPrec (Letter * AA)

readListPrec :: ReadPrec [Letter * AA]

Show (Letter * Unknown)

Methods

showsPrec :: Int -> Letter * Unknown -> ShowS

show :: Letter * Unknown -> String

showList :: [Letter * Unknown] -> ShowS

Show (Letter * DNA)

Methods

showsPrec :: Int -> Letter * DNA -> ShowS

show :: Letter * DNA -> String

showList :: [Letter * DNA] -> ShowS

Show (Letter * RNA)

Methods

showsPrec :: Int -> Letter * RNA -> ShowS

show :: Letter * RNA -> String

showList :: [Letter * RNA] -> ShowS

Show (Letter * XNA)

Methods

showsPrec :: Int -> Letter * XNA -> ShowS

show :: Letter * XNA -> String

showList :: [Letter * XNA] -> ShowS

Show (Letter * DEG)

Methods

showsPrec :: Int -> Letter * DEG -> ShowS

show :: Letter * DEG -> String

showList :: [Letter * DEG] -> ShowS

Show (Letter * AA)

Methods

showsPrec :: Int -> Letter * AA -> ShowS

show :: Letter * AA -> String

showList :: [Letter * AA] -> ShowS

Ix (Letter k t)

Methods

range :: (Letter k t, Letter k t) -> [Letter k t]

index :: (Letter k t, Letter k t) -> Letter k t -> Int

unsafeIndex :: (Letter k t, Letter k t) -> Letter k t -> Int

inRange :: (Letter k t, Letter k t) -> Letter k t -> Bool

rangeSize :: (Letter k t, Letter k t) -> Int

unsafeRangeSize :: (Letter k t, Letter k t) -> Int

Generic (Letter k t)

Associated Types

type Rep (Letter k t) :: * -> *

Methods

from :: Letter k t -> Rep (Letter k t) x

to :: Rep (Letter k t) x -> Letter k t

Index (Letter k l)

Methods

linearIndex :: Letter k l -> Letter k l -> Letter k l -> Int

smallestLinearIndex :: Letter k l -> Int

largestLinearIndex :: Letter k l -> Int

size :: Letter k l -> Letter k l -> Int

inBounds :: Letter k l -> Letter k l -> Letter k l -> Bool

IndexStream z => IndexStream ((:.) z (Letter k l))

Methods

streamUp :: Monad m => (z :. Letter k l) -> (z :. Letter k l) -> Stream m (z :. Letter k l)

streamDown :: Monad m => (z :. Letter k l) -> (z :. Letter k l) -> Stream m (z :. Letter k l)

IndexStream (Letter k l)

Methods

streamUp :: Monad m => Letter k l -> Letter k l -> Stream m (Letter k l)

streamDown :: Monad m => Letter k l -> Letter k l -> Stream m (Letter k l)

Hashable (Letter k t)

Methods

hashWithSalt :: Int -> Letter k t -> Int

hash :: Letter k t -> Int

FromJSON (Letter * Unknown)

Methods

parseJSON :: Value -> Parser (Letter * Unknown)

parseJSONList :: Value -> Parser [Letter * Unknown]

FromJSON (Letter * RNA)

Methods

parseJSON :: Value -> Parser (Letter * RNA)

parseJSONList :: Value -> Parser [Letter * RNA]

FromJSON (Letter * AA)

Methods

parseJSON :: Value -> Parser (Letter * AA)

parseJSONList :: Value -> Parser [Letter * AA]

ToJSON (Letter * Unknown)

Methods

toJSON :: Letter * Unknown -> Value

toEncoding :: Letter * Unknown -> Encoding

toJSONList :: [Letter * Unknown] -> Value

toEncodingList :: [Letter * Unknown] -> Encoding

ToJSON (Letter * RNA)

Methods

toJSON :: Letter * RNA -> Value

toEncoding :: Letter * RNA -> Encoding

toJSONList :: [Letter * RNA] -> Value

toEncodingList :: [Letter * RNA] -> Encoding

ToJSON (Letter * AA)

Methods

toJSON :: Letter * AA -> Value

toEncoding :: Letter * AA -> Encoding

toJSONList :: [Letter * AA] -> Value

toEncodingList :: [Letter * AA] -> Encoding

Binary (Letter k t)

Methods

put :: Letter k t -> Put

get :: Get (Letter k t)

putList :: [Letter k t] -> Put

Serialize (Letter k t)

Methods

put :: Putter (Letter k t)

get :: Get (Letter k t)

NFData (Letter k t)

Methods

rnf :: Letter k t -> ()

Unbox (Letter k a0)

Degenerate (Letter * DNA)

Methods

fromDegenerate :: Char -> [Letter * DNA]

toDegenerate :: [Letter * DNA] -> Maybe Char

Degenerate (Letter * RNA)

Methods

fromDegenerate :: Char -> [Letter * RNA]

toDegenerate :: [Letter * RNA] -> Maybe Char

Degenerate (Letter * XNA)

Methods

fromDegenerate :: Char -> [Letter * XNA]

toDegenerate :: [Letter * XNA] -> Maybe Char

BasepairConvert (Letter * RNA, Letter * RNA) ViennaPair

Methods

basepairConvert :: (Letter * RNA, Letter * RNA) -> ViennaPair

BasepairConvert (Letter * RNA, Letter * RNA) Basepair

Methods

basepairConvert :: (Letter * RNA, Letter * RNA) -> Basepair

LetterChar k x => ToJSON (Pretty * [] (Letter k x))

Methods

toJSON :: Pretty * [] (Letter k x) -> Value

toEncoding :: Pretty * [] (Letter k x) -> Encoding

toJSONList :: [Pretty * [] (Letter k x)] -> Value

toEncodingList :: [Pretty * [] (Letter k x)] -> Encoding

LetterChar k x => ToJSON (Pretty * Vector (Letter k x))

Methods

toJSON :: Pretty * Vector (Letter k x) -> Value

toEncoding :: Pretty * Vector (Letter k x) -> Encoding

toJSONList :: [Pretty * Vector (Letter k x)] -> Value

toEncodingList :: [Pretty * Vector (Letter k x)] -> Encoding

LetterChar k x => ToJSON (Pretty * Vector (Letter k x))

Methods

toJSON :: Pretty * Vector (Letter k x) -> Value

toEncoding :: Pretty * Vector (Letter k x) -> Encoding

toJSONList :: [Pretty * Vector (Letter k x)] -> Value

toEncodingList :: [Pretty * Vector (Letter k x)] -> Encoding

(LetterChar k x, Storable (Letter k x)) => ToJSON (Pretty * Vector (Letter k x))

Methods

toJSON :: Pretty * Vector (Letter k x) -> Value

toEncoding :: Pretty * Vector (Letter k x) -> Encoding

toJSONList :: [Pretty * Vector (Letter k x)] -> Value

toEncodingList :: [Pretty * Vector (Letter k x)] -> Encoding

data MVector s (Letter k a0)

data MVector s (Letter k a0) = MV_Letter (MVector s Int)

type Rep (Letter k t)

type Rep (Letter k t) = D1 (MetaData "Letter" "Biobase.Primary.Letter" "BiobaseXNA-0.10.0.0-KYWIxTC5DTnJ4ZvJWky3ys" True) (C1 (MetaCons "Letter" PrefixI True) (S1 (MetaSel (Just Symbol "getLetter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))

data Vector (Letter k a0)

data Vector (Letter k a0) = V_Letter (Vector Int)

type TranscribeTo (Primary * DNA)

type TranscribeTo (Primary * DNA) = Primary * RNA

type TranscribeTo (Primary * RNA)

type TranscribeTo (Primary * RNA) = Primary * DNA

type TranscribeTo (Letter * DNA)

type TranscribeTo (Letter * DNA) = Letter * RNA

type TranscribeTo (Letter * RNA)

type TranscribeTo (Letter * RNA) = Letter * DNA

type Primary t = Vector (Letter t)

class LetterChar t where

Convert Letter types into character forms. DNA, RNA, and amino acid sequences can make use of this. Other Letter types only if they have single-char representations.

Minimal complete definition

letterChar, charLetter

Methods

letterChar :: Letter t -> Char

charLetter :: Char -> Letter t

Instances

LetterChar * DNA

Methods

letterChar :: Letter DNA t -> Char

charLetter :: Char -> Letter DNA t

LetterChar * RNA

Methods

letterChar :: Letter RNA t -> Char

charLetter :: Char -> Letter RNA t

LetterChar * XNA

Methods

letterChar :: Letter XNA t -> Char

charLetter :: Char -> Letter XNA t

LetterChar * AA

Methods

letterChar :: Letter AA t -> Char

charLetter :: Char -> Letter AA t

class MkPrimary n t where

Conversion from a large number of sequence-like inputs to primary sequences.

Minimal complete definition

primary

Methods

primary :: n -> Primary t

Instances

MkPrimary k (Vector Char) t => MkPrimary k ByteString t

Methods

primary :: t -> Primary ByteString t

MkPrimary k (Vector Char) t => MkPrimary k ByteString t

Methods

primary :: t -> Primary ByteString t

MkPrimary k (Vector Char) t => MkPrimary k Text t

Methods

primary :: t -> Primary Text t

MkPrimary k (Vector Char) t => MkPrimary k Text t

Methods

primary :: t -> Primary Text t

MkPrimary k (Vector Char) t => MkPrimary k String t

Methods

primary :: t -> Primary String t

MkPrimary * (Vector Char) DNA

Methods

primary :: DNA -> Primary (Vector Char) t

MkPrimary * (Vector Char) RNA

Methods

primary :: RNA -> Primary (Vector Char) t

MkPrimary * (Vector Char) XNA

Methods

primary :: XNA -> Primary (Vector Char) t

MkPrimary * (Vector Char) DEG

Methods

primary :: DEG -> Primary (Vector Char) t

MkPrimary * (Vector Char) AA

Methods

primary :: AA -> Primary (Vector Char) t

MkPrimary * (Vector Int) Unknown

Methods

primary :: Unknown -> Primary (Vector Int) t

Instances for Letter.