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

module Bio.Protein.AminoAcid.Instances where

import           Bio.Protein.AminoAcid.Type
import           Bio.Utils.Monomer          (FromSymbol (..),
                                             FromThreeSymbols (..), Symbol (..),
                                             ThreeSymbols (..))
import           Control.Lens               (Const (..), Getting, Identity (..),
                                             Lens', coerced, to, (^.))
import           Data.Array                 (Array, listArray)
import           Data.Coerce                (coerce)
import           Data.Kind                  (Type)
import           Data.String                (IsString (..))

-------------------------------------------------------------------------------
-- Creatable
-------------------------------------------------------------------------------

-- | Single object can be created
--
class Createable a where
    type Create a :: Type
    -- | Function to create single object
    --
    create :: Create a

instance Createable (BB a) where
    type Create (BB a) = a -> a -> a -> BB a
    create :: Create (BB a)
create a
n_ a
ca_ a
c_ = a -> Identity a
coerce (a -> Identity a) -> AminoAcid Identity Identity Identity a -> BB a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identity a
-> Identity a
-> Identity a
-> AminoAcid Identity Identity Identity a
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a.
nr a -> car1 a -> cr a -> AminoAcid nr car1 cr a
AminoAcid (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
n_) (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
ca_) (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
c_)

instance Createable (BBCA a) where
    type Create (BBCA a) = a -> BBCA a
    create :: Create (BBCA a)
create a
ca_ = a -> Identity a
coerce (a -> Identity a)
-> AminoAcid (Const ()) Identity (Const ()) a -> BBCA a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Const () a
-> Identity a
-> Const () a
-> AminoAcid (Const ()) Identity (Const ()) a
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a.
nr a -> car1 a -> cr a -> AminoAcid nr car1 cr a
AminoAcid (() -> Const () a
forall k a (b :: k). a -> Const a b
Const ()) (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
ca_) (() -> Const () a
forall k a (b :: k). a -> Const a b
Const ())

instance Createable (BBT a) where
    type Create (BBT a) = a -> a -> a -> AA -> BBT a
    create :: Create (BBT a)
create a
n_ a
ca_ a
c_ AA
aa = a -> Identity a
coerce (a -> Identity a)
-> AminoAcid Identity (Env (Const AA)) Identity a -> BBT a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identity a
-> Env (Const AA) a
-> Identity a
-> AminoAcid Identity (Env (Const AA)) Identity a
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a.
nr a -> car1 a -> cr a -> AminoAcid nr car1 cr a
AminoAcid (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
n_) (a -> Const AA a -> Env (Const AA) a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env a
ca_ (AA -> Const AA a
forall k a (b :: k). a -> Const a b
Const AA
aa)) (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
c_)

instance Createable (BBCAT a) where
    type Create (BBCAT a) = a -> AA -> BBCAT a
    create :: Create (BBCAT a)
create a
ca_ AA
aa = a -> Identity a
coerce (a -> Identity a)
-> AminoAcid (Const ()) (Env (Const AA)) (Const ()) a -> BBCAT a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Const () a
-> Env (Const AA) a
-> Const () a
-> AminoAcid (Const ()) (Env (Const AA)) (Const ()) a
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a.
nr a -> car1 a -> cr a -> AminoAcid nr car1 cr a
AminoAcid (() -> Const () a
forall k a (b :: k). a -> Const a b
Const ()) (a -> Const AA a -> Env (Const AA) a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env a
ca_ (AA -> Const AA a
forall k a (b :: k). a -> Const a b
Const AA
aa)) (() -> Const () a
forall k a (b :: k). a -> Const a b
Const ())

instance Createable (BBCG a) where
    type Create (BBCG a) = a -> a -> a -> a -> AA -> BBCG a
    create :: Create (BBCG a)
create a
n_ a
ca_ a
c_ a
cg_ AA
aa = a -> Identity a
coerce (a -> Identity a)
-> AminoAcid Identity (Env CG) Identity a -> BBCG a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identity a
-> Env CG a -> Identity a -> AminoAcid Identity (Env CG) Identity a
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a.
nr a -> car1 a -> cr a -> AminoAcid nr car1 cr a
AminoAcid (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
n_) (a -> CG a -> Env CG a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env a
ca_ (a -> AA -> CG a
forall a1. a1 -> AA -> CG a1
CG a
cg_ AA
aa)) (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
c_)

instance Createable (BBO a) where
    type Create (BBO a) = a -> a -> a -> a -> BBO a
    create :: Create (BBO a)
create a
n_ a
ca_ a
c_ a
o_ = a -> Identity a
coerce (a -> Identity a)
-> AminoAcid Identity Identity (Env Identity) a -> BBO a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identity a
-> Identity a
-> Env Identity a
-> AminoAcid Identity Identity (Env Identity) a
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a.
nr a -> car1 a -> cr a -> AminoAcid nr car1 cr a
AminoAcid (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
n_) (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
ca_) (a -> Identity a -> Env Identity a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env a
c_ (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
o_))

instance Createable (BBOT a) where
    type Create (BBOT a) = a -> a -> a -> a -> AA -> BBOT a
    create :: Create (BBOT a)
create a
n_ a
ca_ a
c_ a
o_ AA
aa = a -> Identity a
coerce (a -> Identity a)
-> AminoAcid Identity (Env (Const AA)) (Env Identity) a -> BBOT a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identity a
-> Env (Const AA) a
-> Env Identity a
-> AminoAcid Identity (Env (Const AA)) (Env Identity) a
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a.
nr a -> car1 a -> cr a -> AminoAcid nr car1 cr a
AminoAcid (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
n_) (a -> Const AA a -> Env (Const AA) a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env a
ca_ (AA -> Const AA a
forall k a (b :: k). a -> Const a b
Const AA
aa)) (a -> Identity a -> Env Identity a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env a
c_ (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
o_))

instance Createable (BBOCG a) where
    type Create (BBOCG a) = a -> a -> a -> a -> a -> AA -> BBOCG a
    create :: Create (BBOCG a)
create a
n_ a
ca_ a
c_ a
o_ a
cg_ AA
aa = a -> Identity a
coerce (a -> Identity a)
-> AminoAcid Identity (Env CG) (Env Identity) a -> BBOCG a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identity a
-> Env CG a
-> Env Identity a
-> AminoAcid Identity (Env CG) (Env Identity) a
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a.
nr a -> car1 a -> cr a -> AminoAcid nr car1 cr a
AminoAcid (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
n_) (a -> CG a -> Env CG a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env a
ca_ (a -> AA -> CG a
forall a1. a1 -> AA -> CG a1
CG a
cg_ AA
aa)) (a -> Identity a -> Env Identity a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env a
c_ (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
o_))

instance Createable (BBOR a) where
    type Create (BBOR a) = a -> a -> a -> a -> Radical a -> BBOR a
    create :: Create (BBOR a)
create a
n_ a
ca_ a
c_ a
o_ Radical a
r = a -> Identity a
coerce (a -> Identity a)
-> AminoAcid Identity (Env Radical) (Env Identity) a -> BBOR a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identity a
-> Env Radical a
-> Env Identity a
-> AminoAcid Identity (Env Radical) (Env Identity) a
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a.
nr a -> car1 a -> cr a -> AminoAcid nr car1 cr a
AminoAcid (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
n_) (a -> Radical a -> Env Radical a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env a
ca_ Radical a
r) (a -> Identity a -> Env Identity a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env a
c_ (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
o_))

instance Createable (BBOXTR a) where
    type Create (BBOXTR a) = a -> a -> a -> a -> a -> Radical a -> BBOXTR a
    create :: Create (BBOXTR a)
create a
n_ a
ca_ a
c_ a
o_ a
oxt_ Radical a
r = a -> Identity a
coerce (a -> Identity a)
-> AminoAcid Identity (Env Radical) (Env OXT) a -> BBOXTR a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identity a
-> Env Radical a
-> Env OXT a
-> AminoAcid Identity (Env Radical) (Env OXT) a
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a.
nr a -> car1 a -> cr a -> AminoAcid nr car1 cr a
AminoAcid (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
n_) (a -> Radical a -> Env Radical a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env a
ca_ Radical a
r) (a -> OXT a -> Env OXT a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env a
c_ (a -> a -> OXT a
forall a. a -> a -> OXT a
OXT a
o_ a
oxt_))

instance Createable (BBORH a) where
    type Create (BBORH a) = a -> a -> a -> a -> Radical a -> BBORH a
    create :: Create (BBORH a)
create a
n_ a
ca_ a
c_ a
o_ Radical a
r = (a -> [a] -> Env [] a) -> [a] -> a -> Env [] a
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> [a] -> Env [] a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env [] (a -> Env [] a)
-> AminoAcid Identity (Env Radical) (Env Identity) a -> BBORH a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identity a
-> Env Radical a
-> Env Identity a
-> AminoAcid Identity (Env Radical) (Env Identity) a
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a.
nr a -> car1 a -> cr a -> AminoAcid nr car1 cr a
AminoAcid (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
n_) (a -> Radical a -> Env Radical a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env a
ca_ Radical a
r) (a -> Identity a -> Env Identity a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env a
c_ (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
o_))

instance Createable (BBOXTRH a) where
    type Create (BBOXTRH a) = a -> a -> a -> a -> a -> Radical a -> BBOXTRH a
    create :: Create (BBOXTRH a)
create a
n_ a
ca_ a
c_ a
o_ a
oxt_ Radical a
r = (a -> [a] -> Env [] a) -> [a] -> a -> Env [] a
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> [a] -> Env [] a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env [] (a -> Env [] a)
-> AminoAcid Identity (Env Radical) (Env OXT) a -> BBOXTRH a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identity a
-> Env Radical a
-> Env OXT a
-> AminoAcid Identity (Env Radical) (Env OXT) a
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a.
nr a -> car1 a -> cr a -> AminoAcid nr car1 cr a
AminoAcid (a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
n_) (a -> Radical a -> Env Radical a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env a
ca_ Radical a
r) (a -> OXT a -> Env OXT a
forall (r1 :: * -> *) a. a -> r1 a -> Env r1 a
Env a
c_ (a -> a -> OXT a
forall a. a -> a -> OXT a
OXT a
o_ a
oxt_))

-------------------------------------------------------------------------------
-- HasRadical
-------------------------------------------------------------------------------

-- | Has lens to observe, set and modify radicals
--
class Functor r => HasRadical r where
    type RadicalType r a :: Type
    -- | Lens for radical atom or group
    --
    radical :: (Functor f, Functor g) => Lens' (AminoAcid f (Env r) g a) (RadicalType r a)

instance HasRadical (Const x) where
    type RadicalType (Const x) a = x
    radical :: Lens' (AminoAcid f (Env (Const x)) g a) (RadicalType (Const x) a)
radical = (Env (Const x) a -> f (Env (Const x) a))
-> AminoAcid f (Env (Const x)) g a
-> f (AminoAcid f (Env (Const x)) g a)
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a
       (car2 :: * -> *).
Lens
  (AminoAcid nr car1 cr a) (AminoAcid nr car2 cr a) (car1 a) (car2 a)
ca' ((Env (Const x) a -> f (Env (Const x) a))
 -> AminoAcid f (Env (Const x)) g a
 -> f (AminoAcid f (Env (Const x)) g a))
-> ((x -> f x) -> Env (Const x) a -> f (Env (Const x) a))
-> (x -> f x)
-> AminoAcid f (Env (Const x)) g a
-> f (AminoAcid f (Env (Const x)) g a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Const x a -> f (Const x a))
-> Env (Const x) a -> f (Env (Const x) a)
forall (r1 :: * -> *) a (r2 :: * -> *).
Lens (Env r1 a) (Env r2 a) (r1 a) (r2 a)
environment ((Const x a -> f (Const x a))
 -> Env (Const x) a -> f (Env (Const x) a))
-> ((x -> f x) -> Const x a -> f (Const x a))
-> (x -> f x)
-> Env (Const x) a
-> f (Env (Const x) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (x -> f x) -> Const x a -> f (Const x a)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
coerced

instance HasRadical Radical where
    type RadicalType Radical a = Radical a
    radical :: Lens' (AminoAcid f (Env Radical) g a) (RadicalType Radical a)
radical = (Env Radical a -> f (Env Radical a))
-> AminoAcid f (Env Radical) g a
-> f (AminoAcid f (Env Radical) g a)
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a
       (car2 :: * -> *).
Lens
  (AminoAcid nr car1 cr a) (AminoAcid nr car2 cr a) (car1 a) (car2 a)
ca' ((Env Radical a -> f (Env Radical a))
 -> AminoAcid f (Env Radical) g a
 -> f (AminoAcid f (Env Radical) g a))
-> ((Radical a -> f (Radical a))
    -> Env Radical a -> f (Env Radical a))
-> (Radical a -> f (Radical a))
-> AminoAcid f (Env Radical) g a
-> f (AminoAcid f (Env Radical) g a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Radical a -> f (Radical a)) -> Env Radical a -> f (Env Radical a)
forall (r1 :: * -> *) a (r2 :: * -> *).
Lens (Env r1 a) (Env r2 a) (r1 a) (r2 a)
environment

instance HasRadical CG where
    type RadicalType CG a = a
    radical :: Lens' (AminoAcid f (Env CG) g a) (RadicalType CG a)
radical = (Env CG a -> f (Env CG a))
-> AminoAcid f (Env CG) g a -> f (AminoAcid f (Env CG) g a)
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a
       (car2 :: * -> *).
Lens
  (AminoAcid nr car1 cr a) (AminoAcid nr car2 cr a) (car1 a) (car2 a)
ca' ((Env CG a -> f (Env CG a))
 -> AminoAcid f (Env CG) g a -> f (AminoAcid f (Env CG) g a))
-> ((a -> f a) -> Env CG a -> f (Env CG a))
-> (a -> f a)
-> AminoAcid f (Env CG) g a
-> f (AminoAcid f (Env CG) g a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CG a -> f (CG a)) -> Env CG a -> f (Env CG a)
forall (r1 :: * -> *) a (r2 :: * -> *).
Lens (Env r1 a) (Env r2 a) (r1 a) (r2 a)
environment ((CG a -> f (CG a)) -> Env CG a -> f (Env CG a))
-> ((a -> f a) -> CG a -> f (CG a))
-> (a -> f a)
-> Env CG a
-> f (Env CG a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f a) -> CG a -> f (CG a)
forall a1 a2. Lens (CG a1) (CG a2) a1 a2
cg'

instance HasRadical Identity where
    type RadicalType Identity a = a
    radical :: Lens' (AminoAcid f (Env Identity) g a) (RadicalType Identity a)
radical = (Env Identity a -> f (Env Identity a))
-> AminoAcid f (Env Identity) g a
-> f (AminoAcid f (Env Identity) g a)
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a
       (car2 :: * -> *).
Lens
  (AminoAcid nr car1 cr a) (AminoAcid nr car2 cr a) (car1 a) (car2 a)
ca' ((Env Identity a -> f (Env Identity a))
 -> AminoAcid f (Env Identity) g a
 -> f (AminoAcid f (Env Identity) g a))
-> ((a -> f a) -> Env Identity a -> f (Env Identity a))
-> (a -> f a)
-> AminoAcid f (Env Identity) g a
-> f (AminoAcid f (Env Identity) g a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identity a -> f (Identity a))
-> Env Identity a -> f (Env Identity a)
forall (r1 :: * -> *) a (r2 :: * -> *).
Lens (Env r1 a) (Env r2 a) (r1 a) (r2 a)
environment ((Identity a -> f (Identity a))
 -> Env Identity a -> f (Env Identity a))
-> ((a -> f a) -> Identity a -> f (Identity a))
-> (a -> f a)
-> Env Identity a
-> f (Env Identity a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f a) -> Identity a -> f (Identity a)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
coerced

-------------------------------------------------------------------------------
-- HasRadicalType
-------------------------------------------------------------------------------

-- | Has lens to observe radical types
--
class Functor r => HasRadicalType r where
    -- | Getter for radical type
    --
    radicalType :: (Functor f, Functor g) => Getting AA (AminoAcid f (Env r) g a) AA

instance HasRadicalType (Const AA) where
    radicalType :: Getting AA (AminoAcid f (Env (Const AA)) g a) AA
radicalType = (Env (Const AA) a -> Const AA (Env (Const AA) a))
-> AminoAcid f (Env (Const AA)) g a
-> Const AA (AminoAcid f (Env (Const AA)) g a)
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a
       (car2 :: * -> *).
Lens
  (AminoAcid nr car1 cr a) (AminoAcid nr car2 cr a) (car1 a) (car2 a)
ca' ((Env (Const AA) a -> Const AA (Env (Const AA) a))
 -> AminoAcid f (Env (Const AA)) g a
 -> Const AA (AminoAcid f (Env (Const AA)) g a))
-> ((AA -> Const AA AA)
    -> Env (Const AA) a -> Const AA (Env (Const AA) a))
-> Getting AA (AminoAcid f (Env (Const AA)) g a) AA
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Const AA a -> Const AA (Const AA a))
-> Env (Const AA) a -> Const AA (Env (Const AA) a)
forall (r1 :: * -> *) a (r2 :: * -> *).
Lens (Env r1 a) (Env r2 a) (r1 a) (r2 a)
environment ((Const AA a -> Const AA (Const AA a))
 -> Env (Const AA) a -> Const AA (Env (Const AA) a))
-> ((AA -> Const AA AA) -> Const AA a -> Const AA (Const AA a))
-> (AA -> Const AA AA)
-> Env (Const AA) a
-> Const AA (Env (Const AA) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (AA -> Const AA AA) -> Const AA a -> Const AA (Const AA a)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
coerced

instance HasRadicalType CG where
    radicalType :: Getting AA (AminoAcid f (Env CG) g a) AA
radicalType = (Env CG a -> Const AA (Env CG a))
-> AminoAcid f (Env CG) g a -> Const AA (AminoAcid f (Env CG) g a)
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a
       (car2 :: * -> *).
Lens
  (AminoAcid nr car1 cr a) (AminoAcid nr car2 cr a) (car1 a) (car2 a)
ca' ((Env CG a -> Const AA (Env CG a))
 -> AminoAcid f (Env CG) g a -> Const AA (AminoAcid f (Env CG) g a))
-> ((AA -> Const AA AA) -> Env CG a -> Const AA (Env CG a))
-> Getting AA (AminoAcid f (Env CG) g a) AA
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CG a -> Const AA (CG a)) -> Env CG a -> Const AA (Env CG a)
forall (r1 :: * -> *) a (r2 :: * -> *).
Lens (Env r1 a) (Env r2 a) (r1 a) (r2 a)
environment ((CG a -> Const AA (CG a)) -> Env CG a -> Const AA (Env CG a))
-> ((AA -> Const AA AA) -> CG a -> Const AA (CG a))
-> (AA -> Const AA AA)
-> Env CG a
-> Const AA (Env CG a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (AA -> Const AA AA) -> CG a -> Const AA (CG a)
forall a1. Lens' (CG a1) AA
radical' ((AA -> Const AA AA) -> CG a -> Const AA (CG a))
-> ((AA -> Const AA AA) -> AA -> Const AA AA)
-> (AA -> Const AA AA)
-> CG a
-> Const AA (CG a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (AA -> Const AA AA) -> AA -> Const AA AA
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
coerced

instance HasRadicalType Radical where
    radicalType :: Getting AA (AminoAcid f (Env Radical) g a) AA
radicalType = (Env Radical a -> Const AA (Env Radical a))
-> AminoAcid f (Env Radical) g a
-> Const AA (AminoAcid f (Env Radical) g a)
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a
       (car2 :: * -> *).
Lens
  (AminoAcid nr car1 cr a) (AminoAcid nr car2 cr a) (car1 a) (car2 a)
ca' ((Env Radical a -> Const AA (Env Radical a))
 -> AminoAcid f (Env Radical) g a
 -> Const AA (AminoAcid f (Env Radical) g a))
-> ((AA -> Const AA AA)
    -> Env Radical a -> Const AA (Env Radical a))
-> Getting AA (AminoAcid f (Env Radical) g a) AA
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Radical a -> Const AA (Radical a))
-> Env Radical a -> Const AA (Env Radical a)
forall (r1 :: * -> *) a (r2 :: * -> *).
Lens (Env r1 a) (Env r2 a) (r1 a) (r2 a)
environment ((Radical a -> Const AA (Radical a))
 -> Env Radical a -> Const AA (Env Radical a))
-> ((AA -> Const AA AA) -> Radical a -> Const AA (Radical a))
-> (AA -> Const AA AA)
-> Env Radical a
-> Const AA (Env Radical a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Radical a -> AA)
-> (AA -> Const AA AA) -> Radical a -> Const AA (Radical a)
forall (p :: * -> * -> *) (f :: * -> *) s a.
(Profunctor p, Contravariant f) =>
(s -> a) -> Optic' p f s a
to Radical a -> AA
forall a. Radical a -> AA
rad2rad

-------------------------------------------------------------------------------
-- Has some atom
-------------------------------------------------------------------------------

-- | Has lens to observe, set and modify ca_ atom
--
class Functor r => HasCA r where
    -- | Lens for ca_ atom
    --
    ca :: (Functor f, Functor g) => Lens' (AminoAcid f r g a) a

instance HasCA Identity where
    ca :: Lens' (AminoAcid f Identity g a) a
ca = (Identity a -> f (Identity a))
-> AminoAcid f Identity g a -> f (AminoAcid f Identity g a)
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a
       (car2 :: * -> *).
Lens
  (AminoAcid nr car1 cr a) (AminoAcid nr car2 cr a) (car1 a) (car2 a)
ca' ((Identity a -> f (Identity a))
 -> AminoAcid f Identity g a -> f (AminoAcid f Identity g a))
-> ((a -> f a) -> Identity a -> f (Identity a))
-> (a -> f a)
-> AminoAcid f Identity g a
-> f (AminoAcid f Identity g a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f a) -> Identity a -> f (Identity a)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
coerced

instance Functor f => HasCA (Env f) where
    ca :: Lens' (AminoAcid f (Env f) g a) a
ca = (Env f a -> f (Env f a))
-> AminoAcid f (Env f) g a -> f (AminoAcid f (Env f) g a)
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a
       (car2 :: * -> *).
Lens
  (AminoAcid nr car1 cr a) (AminoAcid nr car2 cr a) (car1 a) (car2 a)
ca' ((Env f a -> f (Env f a))
 -> AminoAcid f (Env f) g a -> f (AminoAcid f (Env f) g a))
-> ((a -> f a) -> Env f a -> f (Env f a))
-> (a -> f a)
-> AminoAcid f (Env f) g a
-> f (AminoAcid f (Env f) g a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f a) -> Env f a -> f (Env f a)
forall (r1 :: * -> *) a. Lens' (Env r1 a) a
atom'

-- | Has lens to observe, set and modify c_ atom
--
class Functor r => HasC r where
    -- | Lens for c_ atom
    --
    c :: (Functor f, Functor g) => Lens' (AminoAcid f g r a) a

instance HasC Identity where
    c :: Lens' (AminoAcid f g Identity a) a
c = (Identity a -> f (Identity a))
-> AminoAcid f g Identity a -> f (AminoAcid f g Identity a)
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a
       (cr2 :: * -> *).
Lens
  (AminoAcid nr car1 cr a) (AminoAcid nr car1 cr2 a) (cr a) (cr2 a)
c' ((Identity a -> f (Identity a))
 -> AminoAcid f g Identity a -> f (AminoAcid f g Identity a))
-> ((a -> f a) -> Identity a -> f (Identity a))
-> (a -> f a)
-> AminoAcid f g Identity a
-> f (AminoAcid f g Identity a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f a) -> Identity a -> f (Identity a)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
coerced

instance Functor f => HasC (Env f) where
    c :: Lens' (AminoAcid f g (Env f) a) a
c = (Env f a -> f (Env f a))
-> AminoAcid f g (Env f) a -> f (AminoAcid f g (Env f) a)
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a
       (cr2 :: * -> *).
Lens
  (AminoAcid nr car1 cr a) (AminoAcid nr car1 cr2 a) (cr a) (cr2 a)
c' ((Env f a -> f (Env f a))
 -> AminoAcid f g (Env f) a -> f (AminoAcid f g (Env f) a))
-> ((a -> f a) -> Env f a -> f (Env f a))
-> (a -> f a)
-> AminoAcid f g (Env f) a
-> f (AminoAcid f g (Env f) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f a) -> Env f a -> f (Env f a)
forall (r1 :: * -> *) a. Lens' (Env r1 a) a
atom'

-- | Has lens to observe, set and modify o_ atom
--
class Functor r => HasO r where
    -- | Lens for o_ atom
    --
    o :: (Functor f, Functor g) => Lens' (AminoAcid f g (Env r) a) a

instance HasO Identity where
    o :: Lens' (AminoAcid f g (Env Identity) a) a
o = (Env Identity a -> f (Env Identity a))
-> AminoAcid f g (Env Identity) a
-> f (AminoAcid f g (Env Identity) a)
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a
       (cr2 :: * -> *).
Lens
  (AminoAcid nr car1 cr a) (AminoAcid nr car1 cr2 a) (cr a) (cr2 a)
c' ((Env Identity a -> f (Env Identity a))
 -> AminoAcid f g (Env Identity) a
 -> f (AminoAcid f g (Env Identity) a))
-> ((a -> f a) -> Env Identity a -> f (Env Identity a))
-> (a -> f a)
-> AminoAcid f g (Env Identity) a
-> f (AminoAcid f g (Env Identity) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identity a -> f (Identity a))
-> Env Identity a -> f (Env Identity a)
forall (r1 :: * -> *) a (r2 :: * -> *).
Lens (Env r1 a) (Env r2 a) (r1 a) (r2 a)
environment ((Identity a -> f (Identity a))
 -> Env Identity a -> f (Env Identity a))
-> ((a -> f a) -> Identity a -> f (Identity a))
-> (a -> f a)
-> Env Identity a
-> f (Env Identity a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f a) -> Identity a -> f (Identity a)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
coerced

instance HasO OXT where
    o :: Lens' (AminoAcid f g (Env OXT) a) a
o = (Env OXT a -> f (Env OXT a))
-> AminoAcid f g (Env OXT) a -> f (AminoAcid f g (Env OXT) a)
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a
       (cr2 :: * -> *).
Lens
  (AminoAcid nr car1 cr a) (AminoAcid nr car1 cr2 a) (cr a) (cr2 a)
c' ((Env OXT a -> f (Env OXT a))
 -> AminoAcid f g (Env OXT) a -> f (AminoAcid f g (Env OXT) a))
-> ((a -> f a) -> Env OXT a -> f (Env OXT a))
-> (a -> f a)
-> AminoAcid f g (Env OXT) a
-> f (AminoAcid f g (Env OXT) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (OXT a -> f (OXT a)) -> Env OXT a -> f (Env OXT a)
forall (r1 :: * -> *) a (r2 :: * -> *).
Lens (Env r1 a) (Env r2 a) (r1 a) (r2 a)
environment ((OXT a -> f (OXT a)) -> Env OXT a -> f (Env OXT a))
-> ((a -> f a) -> OXT a -> f (OXT a))
-> (a -> f a)
-> Env OXT a
-> f (Env OXT a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f a) -> OXT a -> f (OXT a)
forall a. Lens' (OXT a) a
o'

-- | Has lens to observe, set and modify OXT atom
--
class Functor r => HasOXT r where
    -- | Lens for OXT atom
    --
    oxt :: (Functor f, Functor g) => Lens' (AminoAcid f g (Env r) a) a

instance HasOXT OXT where
    oxt :: Lens' (AminoAcid f g (Env OXT) a) a
oxt = (Env OXT a -> f (Env OXT a))
-> AminoAcid f g (Env OXT) a -> f (AminoAcid f g (Env OXT) a)
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a
       (cr2 :: * -> *).
Lens
  (AminoAcid nr car1 cr a) (AminoAcid nr car1 cr2 a) (cr a) (cr2 a)
c' ((Env OXT a -> f (Env OXT a))
 -> AminoAcid f g (Env OXT) a -> f (AminoAcid f g (Env OXT) a))
-> ((a -> f a) -> Env OXT a -> f (Env OXT a))
-> (a -> f a)
-> AminoAcid f g (Env OXT) a
-> f (AminoAcid f g (Env OXT) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (OXT a -> f (OXT a)) -> Env OXT a -> f (Env OXT a)
forall (r1 :: * -> *) a (r2 :: * -> *).
Lens (Env r1 a) (Env r2 a) (r1 a) (r2 a)
environment ((OXT a -> f (OXT a)) -> Env OXT a -> f (Env OXT a))
-> ((a -> f a) -> OXT a -> f (OXT a))
-> (a -> f a)
-> Env OXT a
-> f (Env OXT a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f a) -> OXT a -> f (OXT a)
forall a. Lens' (OXT a) a
oxt'

-- | Has lens to observe, set and modify n_ atom
--
class Functor r => HasN r where
    -- | Lens for n_ atom
    --
    n :: (Functor f, Functor g) => Lens' (AminoAcid r f g a) a

instance HasN Identity where
    n :: Lens' (AminoAcid Identity f g a) a
n = (Identity a -> f (Identity a))
-> AminoAcid Identity f g a -> f (AminoAcid Identity f g a)
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a
       (nr2 :: * -> *).
Lens
  (AminoAcid nr car1 cr a) (AminoAcid nr2 car1 cr a) (nr a) (nr2 a)
n' ((Identity a -> f (Identity a))
 -> AminoAcid Identity f g a -> f (AminoAcid Identity f g a))
-> ((a -> f a) -> Identity a -> f (Identity a))
-> (a -> f a)
-> AminoAcid Identity f g a
-> f (AminoAcid Identity f g a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f a) -> Identity a -> f (Identity a)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
coerced

instance Functor f => HasN (Env f) where
    n :: Lens' (AminoAcid (Env f) f g a) a
n = (Env f a -> f (Env f a))
-> AminoAcid (Env f) f g a -> f (AminoAcid (Env f) f g a)
forall (nr :: * -> *) (car1 :: * -> *) (cr :: * -> *) a
       (nr2 :: * -> *).
Lens
  (AminoAcid nr car1 cr a) (AminoAcid nr2 car1 cr a) (nr a) (nr2 a)
n' ((Env f a -> f (Env f a))
 -> AminoAcid (Env f) f g a -> f (AminoAcid (Env f) f g a))
-> ((a -> f a) -> Env f a -> f (Env f a))
-> (a -> f a)
-> AminoAcid (Env f) f g a
-> f (AminoAcid (Env f) f g a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f a) -> Env f a -> f (Env f a)
forall (r1 :: * -> *) a. Lens' (Env r1 a) a
atom'

-- | Lens to get atom from some enviroment
--
class Functor f => HasAtom f where
    -- | Lens for exact atom get
    --
    atom :: Lens' (f a) a

instance HasAtom Identity where
    atom :: (a -> f a) -> Identity a -> f (Identity a)
atom = (a -> f a) -> Identity a -> f (Identity a)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
coerced

instance Functor r => HasAtom (Env r) where
    atom :: (a -> f a) -> Env r a -> f (Env r a)
atom = (a -> f a) -> Env r a -> f (Env r a)
forall (r1 :: * -> *) a. Lens' (Env r1 a) a
atom'

-- | Lens to get hydrogens from hydrated atom
--
hydrogens :: Lens' (Env [] a) [a]
hydrogens :: ([a] -> f [a]) -> Env [] a -> f (Env [] a)
hydrogens = ([a] -> f [a]) -> Env [] a -> f (Env [] a)
forall (r1 :: * -> *) a (r2 :: * -> *).
Lens (Env r1 a) (Env r2 a) (r1 a) (r2 a)
environment

-------------------------------------------------------------------------------
-- Symbol and ThreeSymbols
-------------------------------------------------------------------------------

-- | Lens to get Symbol from every suitable amino acid
--
instance (Functor nr, HasRadicalType car, Functor cr) => Symbol (AminoAcid nr (Env car) cr a) where
    symbol :: AminoAcid nr (Env car) cr a -> Char
symbol = AA -> Char
forall a. Symbol a => a -> Char
symbol (AA -> Char)
-> (AminoAcid nr (Env car) cr a -> AA)
-> AminoAcid nr (Env car) cr a
-> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (AminoAcid nr (Env car) cr a
-> Getting AA (AminoAcid nr (Env car) cr a) AA -> AA
forall s a. s -> Getting a s a -> a
^. Getting AA (AminoAcid nr (Env car) cr a) AA
forall (r :: * -> *) (f :: * -> *) (g :: * -> *) a.
(HasRadicalType r, Functor f, Functor g) =>
Getting AA (AminoAcid f (Env r) g a) AA
radicalType)

-- | Symbol encoding
--
instance Symbol AA where
    symbol :: AA -> Char
symbol AA
ALA = Char
'A'
    symbol AA
CYS = Char
'C'
    symbol AA
ASP = Char
'D'
    symbol AA
GLU = Char
'E'
    symbol AA
PHE = Char
'F'
    symbol AA
GLY = Char
'G'
    symbol AA
HIS = Char
'H'
    symbol AA
ILE = Char
'I'
    symbol AA
LYS = Char
'K'
    symbol AA
LEU = Char
'L'
    symbol AA
MET = Char
'M'
    symbol AA
ASN = Char
'N'
    symbol AA
PRO = Char
'P'
    symbol AA
GLN = Char
'Q'
    symbol AA
ARG = Char
'R'
    symbol AA
SER = Char
'S'
    symbol AA
THR = Char
'T'
    symbol AA
VAL = Char
'V'
    symbol AA
TRP = Char
'W'
    symbol AA
TYR = Char
'Y'

-- | Parse symbol encoding
--
instance FromSymbol AA where
    fromSymbolE :: Char -> Either Char AA
fromSymbolE Char
'A' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
ALA
    fromSymbolE Char
'C' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
CYS
    fromSymbolE Char
'D' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
ASP
    fromSymbolE Char
'E' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
GLU
    fromSymbolE Char
'F' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
PHE
    fromSymbolE Char
'G' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
GLY
    fromSymbolE Char
'H' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
HIS
    fromSymbolE Char
'I' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
ILE
    fromSymbolE Char
'K' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
LYS
    fromSymbolE Char
'L' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
LEU
    fromSymbolE Char
'M' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
MET
    fromSymbolE Char
'N' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
ASN
    fromSymbolE Char
'P' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
PRO
    fromSymbolE Char
'Q' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
GLN
    fromSymbolE Char
'R' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
ARG
    fromSymbolE Char
'S' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
SER
    fromSymbolE Char
'T' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
THR
    fromSymbolE Char
'V' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
VAL
    fromSymbolE Char
'W' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
TRP
    fromSymbolE Char
'Y' = AA -> Either Char AA
forall a b. b -> Either a b
Right AA
TYR
    fromSymbolE Char
ch  = Char -> Either Char AA
forall a b. a -> Either a b
Left Char
ch

-- | Three symbols encoding
--
instance ThreeSymbols AA where
    threeSymbols :: AA -> Text
threeSymbols AA
ALA = Text
"ALA"
    threeSymbols AA
CYS = Text
"CYS"
    threeSymbols AA
ASP = Text
"ASP"
    threeSymbols AA
GLU = Text
"GLU"
    threeSymbols AA
PHE = Text
"PHE"
    threeSymbols AA
GLY = Text
"GLY"
    threeSymbols AA
HIS = Text
"HIS"
    threeSymbols AA
ILE = Text
"ILE"
    threeSymbols AA
LYS = Text
"LYS"
    threeSymbols AA
LEU = Text
"LEU"
    threeSymbols AA
MET = Text
"MET"
    threeSymbols AA
ASN = Text
"ASN"
    threeSymbols AA
PRO = Text
"PRO"
    threeSymbols AA
GLN = Text
"GLN"
    threeSymbols AA
ARG = Text
"ARG"
    threeSymbols AA
SER = Text
"SER"
    threeSymbols AA
THR = Text
"THR"
    threeSymbols AA
VAL = Text
"VAL"
    threeSymbols AA
TRP = Text
"TRP"
    threeSymbols AA
TYR = Text
"TYR"

-- | Parse three symbols encoding
--
instance FromThreeSymbols AA where
    fromThreeSymbols :: Text -> Maybe AA
fromThreeSymbols Text
"ALA" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
ALA
    fromThreeSymbols Text
"CYS" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
CYS
    fromThreeSymbols Text
"ASP" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
ASP
    fromThreeSymbols Text
"GLU" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
GLU
    fromThreeSymbols Text
"PHE" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
PHE
    fromThreeSymbols Text
"GLY" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
GLY
    fromThreeSymbols Text
"HIS" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
HIS
    fromThreeSymbols Text
"ILE" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
ILE
    fromThreeSymbols Text
"LYS" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
LYS
    fromThreeSymbols Text
"LEU" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
LEU
    fromThreeSymbols Text
"MET" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
MET
    fromThreeSymbols Text
"ASN" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
ASN
    fromThreeSymbols Text
"PRO" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
PRO
    fromThreeSymbols Text
"GLN" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
GLN
    fromThreeSymbols Text
"ARG" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
ARG
    fromThreeSymbols Text
"SER" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
SER
    fromThreeSymbols Text
"THR" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
THR
    fromThreeSymbols Text
"VAL" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
VAL
    fromThreeSymbols Text
"TRP" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
TRP
    fromThreeSymbols Text
"TYR" = AA -> Maybe AA
forall a. a -> Maybe a
Just AA
TYR
    fromThreeSymbols Text
_     = Maybe AA
forall a. Maybe a
Nothing

-------------------------------------------------------------------------------
-- IsString
-------------------------------------------------------------------------------

instance {-# OVERLAPPING #-} IsString [AA] where
    fromString :: String -> [AA]
fromString String
s =
        case (Char -> Either Char AA) -> String -> Either Char [AA]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Char -> Either Char AA
forall a. FromSymbol a => Char -> Either Char a
fromSymbolE String
s of
            Right [AA]
l -> [AA]
l
            Left Char
e  -> String -> [AA]
forall a. HasCallStack => String -> a
error (String -> [AA]) -> String -> [AA]
forall a b. (a -> b) -> a -> b
$ String
"Bio.Protein.AminoAcid.Instances: could not read aminoacid " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> [Char
e]

instance IsString (Array Int AA) where
    fromString :: String -> Array Int AA
fromString String
s = (Int, Int) -> [AA] -> Array Int AA
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0, String -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length String
s Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) ([AA] -> Array Int AA) -> [AA] -> Array Int AA
forall a b. (a -> b) -> a -> b
$ String -> [AA]
forall a. IsString a => String -> a
fromString String
s