{-# LANGUAGE DeriveGeneric     #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TemplateHaskell   #-}

module Poseidon.ColumnTypesJanno where

import           Poseidon.AccessionIDs
import           Poseidon.ColumnTypesUtils

import           Country                    (Country, alphaTwoUpper,
                                             decodeAlphaTwo)
import qualified Data.ByteString.Char8      as B
import qualified Data.Char                  as C
import qualified Data.Csv                   as Csv
import           Data.String                (IsString (..))
import qualified Data.Text                  as T
import qualified Data.Text.Read             as T
import           Data.Version               (makeVersion)
import           GHC.Generics               (Generic)
import           Network.URI                (isURIReference)
import           Poseidon.PoseidonVersion
import           SequenceFormats.Eigenstrat (Sex (..))

-- | A datatype for the Genetic_Sex .janno column
newtype GeneticSex = GeneticSex { GeneticSex -> Sex
sfSex :: Sex } deriving (GeneticSex -> GeneticSex -> Bool
(GeneticSex -> GeneticSex -> Bool)
-> (GeneticSex -> GeneticSex -> Bool) -> Eq GeneticSex
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GeneticSex -> GeneticSex -> Bool
== :: GeneticSex -> GeneticSex -> Bool
$c/= :: GeneticSex -> GeneticSex -> Bool
/= :: GeneticSex -> GeneticSex -> Bool
Eq)

instance Makeable GeneticSex where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m GeneticSex
make PoseidonVersion
_ Text
x
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"F"  = GeneticSex -> m GeneticSex
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Sex -> GeneticSex
GeneticSex Sex
Female)
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"M"  = GeneticSex -> m GeneticSex
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Sex -> GeneticSex
GeneticSex Sex
Male)
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"U"  = GeneticSex -> m GeneticSex
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Sex -> GeneticSex
GeneticSex Sex
Unknown)
        | Bool
otherwise = [Char] -> m GeneticSex
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m GeneticSex) -> [Char] -> m GeneticSex
forall a b. (a -> b) -> a -> b
$ [Char]
"Genetic_Sex is set to " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
". " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
                             [Char]
"That is not in the allowed set [F, M, U]."
instance Suspicious GeneticSex where inspect :: GeneticSex -> Maybe [[Char]]
inspect GeneticSex
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show GeneticSex where
    show :: GeneticSex -> [Char]
show (GeneticSex Sex
Female)  = [Char]
"F"
    show (GeneticSex Sex
Male)    = [Char]
"M"
    show (GeneticSex Sex
Unknown) = [Char]
"U"
instance Ord GeneticSex where
    compare :: GeneticSex -> GeneticSex -> Ordering
compare (GeneticSex Sex
Female) (GeneticSex Sex
Male)    = Ordering
GT
    compare (GeneticSex Sex
Male) (GeneticSex Sex
Female)    = Ordering
LT
    compare (GeneticSex Sex
Male) (GeneticSex Sex
Unknown)   = Ordering
GT
    compare (GeneticSex Sex
Unknown) (GeneticSex Sex
Male)   = Ordering
LT
    compare (GeneticSex Sex
Female) (GeneticSex Sex
Unknown) = Ordering
GT
    compare (GeneticSex Sex
Unknown) (GeneticSex Sex
Female) = Ordering
LT
    compare GeneticSex
_ GeneticSex
_                                      = Ordering
EQ
instance Csv.ToField GeneticSex where   toField :: GeneticSex -> Field
toField GeneticSex
x  = [Char] -> Field
forall a. ToField a => a -> Field
Csv.toField ([Char] -> Field) -> [Char] -> Field
forall a b. (a -> b) -> a -> b
$ GeneticSex -> [Char]
forall a. Show a => a -> [Char]
show GeneticSex
x
instance FromFieldVersioned GeneticSex where parseFieldVersioned :: PoseidonVersion -> Field -> Parser GeneticSex
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser GeneticSex
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Genetic_Sex"

newtype PoseidonID = PoseidonID {PoseidonID -> Field
unPoseidonID :: B.ByteString} deriving (PoseidonID -> PoseidonID -> Bool
(PoseidonID -> PoseidonID -> Bool)
-> (PoseidonID -> PoseidonID -> Bool) -> Eq PoseidonID
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PoseidonID -> PoseidonID -> Bool
== :: PoseidonID -> PoseidonID -> Bool
$c/= :: PoseidonID -> PoseidonID -> Bool
/= :: PoseidonID -> PoseidonID -> Bool
Eq, Eq PoseidonID
Eq PoseidonID =>
(PoseidonID -> PoseidonID -> Ordering)
-> (PoseidonID -> PoseidonID -> Bool)
-> (PoseidonID -> PoseidonID -> Bool)
-> (PoseidonID -> PoseidonID -> Bool)
-> (PoseidonID -> PoseidonID -> Bool)
-> (PoseidonID -> PoseidonID -> PoseidonID)
-> (PoseidonID -> PoseidonID -> PoseidonID)
-> Ord PoseidonID
PoseidonID -> PoseidonID -> Bool
PoseidonID -> PoseidonID -> Ordering
PoseidonID -> PoseidonID -> PoseidonID
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
$ccompare :: PoseidonID -> PoseidonID -> Ordering
compare :: PoseidonID -> PoseidonID -> Ordering
$c< :: PoseidonID -> PoseidonID -> Bool
< :: PoseidonID -> PoseidonID -> Bool
$c<= :: PoseidonID -> PoseidonID -> Bool
<= :: PoseidonID -> PoseidonID -> Bool
$c> :: PoseidonID -> PoseidonID -> Bool
> :: PoseidonID -> PoseidonID -> Bool
$c>= :: PoseidonID -> PoseidonID -> Bool
>= :: PoseidonID -> PoseidonID -> Bool
$cmax :: PoseidonID -> PoseidonID -> PoseidonID
max :: PoseidonID -> PoseidonID -> PoseidonID
$cmin :: PoseidonID -> PoseidonID -> PoseidonID
min :: PoseidonID -> PoseidonID -> PoseidonID
Ord)

instance Makeable PoseidonID where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m PoseidonID
make PoseidonVersion
_ Text
x = (PoseidonID -> m PoseidonID
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (PoseidonID -> m PoseidonID)
-> (Text -> PoseidonID) -> Text -> m PoseidonID
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Field -> PoseidonID
PoseidonID (Field -> PoseidonID) -> (Text -> Field) -> Text -> PoseidonID
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Field
B.pack ([Char] -> Field) -> (Text -> [Char]) -> Text -> Field
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Char]
T.unpack) Text
x

isRecommendedPoseidonIDChar :: Char -> Bool
isRecommendedPoseidonIDChar :: Char -> Bool
isRecommendedPoseidonIDChar Char
c =
    Char -> Bool
C.isAscii Char
c Bool -> Bool -> Bool
&& (Char -> Bool
C.isAlphaNum Char
c Bool -> Bool -> Bool
|| Char
c Char -> [Char] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Char
'_', Char
'-', Char
'.'])

instance Suspicious PoseidonID where
    inspect :: PoseidonID -> Maybe [[Char]]
inspect PoseidonID
id_ = if (Char -> Bool) -> Field -> Bool
B.all Char -> Bool
isRecommendedPoseidonIDChar (PoseidonID -> Field
unPoseidonID PoseidonID
id_)
                  then Maybe [[Char]]
forall a. Maybe a
Nothing
                  else [[Char]] -> Maybe [[Char]]
forall a. a -> Maybe a
Just [[Char]
"PoseidonID should only contain alphanumeric characters and '_', '-', '.': "  [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
                             Field -> [Char]
B.unpack (PoseidonID -> Field
unPoseidonID PoseidonID
id_)]

instance Show PoseidonID where
    show :: PoseidonID -> [Char]
show (PoseidonID Field
x) = Field -> [Char]
B.unpack Field
x

instance Csv.ToField PoseidonID where
    toField :: PoseidonID -> Field
toField (PoseidonID Field
x) = Field -> Field
forall a. ToField a => a -> Field
Csv.toField Field
x

instance FromFieldVersioned PoseidonID where
    parseFieldVersioned :: PoseidonVersion -> Field -> Parser PoseidonID
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser PoseidonID
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"PoseidonID"

-- the IsString instance allows us to write PoseidonID "MyID" directly, mainly for testing purposes.
instance IsString PoseidonID where
    fromString :: [Char] -> PoseidonID
fromString [Char]
str = Field -> PoseidonID
PoseidonID ([Char] -> Field
B.pack [Char]
str)

-- | A datatype for the Group_Name .janno column
newtype GroupName = GroupName {GroupName -> Field
unGroupName :: B.ByteString} deriving (GroupName -> GroupName -> Bool
(GroupName -> GroupName -> Bool)
-> (GroupName -> GroupName -> Bool) -> Eq GroupName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GroupName -> GroupName -> Bool
== :: GroupName -> GroupName -> Bool
$c/= :: GroupName -> GroupName -> Bool
/= :: GroupName -> GroupName -> Bool
Eq, Eq GroupName
Eq GroupName =>
(GroupName -> GroupName -> Ordering)
-> (GroupName -> GroupName -> Bool)
-> (GroupName -> GroupName -> Bool)
-> (GroupName -> GroupName -> Bool)
-> (GroupName -> GroupName -> Bool)
-> (GroupName -> GroupName -> GroupName)
-> (GroupName -> GroupName -> GroupName)
-> Ord GroupName
GroupName -> GroupName -> Bool
GroupName -> GroupName -> Ordering
GroupName -> GroupName -> GroupName
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
$ccompare :: GroupName -> GroupName -> Ordering
compare :: GroupName -> GroupName -> Ordering
$c< :: GroupName -> GroupName -> Bool
< :: GroupName -> GroupName -> Bool
$c<= :: GroupName -> GroupName -> Bool
<= :: GroupName -> GroupName -> Bool
$c> :: GroupName -> GroupName -> Bool
> :: GroupName -> GroupName -> Bool
$c>= :: GroupName -> GroupName -> Bool
>= :: GroupName -> GroupName -> Bool
$cmax :: GroupName -> GroupName -> GroupName
max :: GroupName -> GroupName -> GroupName
$cmin :: GroupName -> GroupName -> GroupName
min :: GroupName -> GroupName -> GroupName
Ord)

instance Makeable GroupName where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m GroupName
make PoseidonVersion
_ Text
x = (GroupName -> m GroupName
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (GroupName -> m GroupName)
-> (Text -> GroupName) -> Text -> m GroupName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Field -> GroupName
GroupName (Field -> GroupName) -> (Text -> Field) -> Text -> GroupName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Field
B.pack ([Char] -> Field) -> (Text -> [Char]) -> Text -> Field
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Char]
T.unpack) Text
x

instance Suspicious GroupName where
    inspect :: GroupName -> Maybe [[Char]]
inspect GroupName
groupName = if (Char -> Bool) -> Field -> Bool
B.all Char -> Bool
isRecommendedPoseidonIDChar (GroupName -> Field
unGroupName GroupName
groupName)
                        then Maybe [[Char]]
forall a. Maybe a
Nothing
                        else [[Char]] -> Maybe [[Char]]
forall a. a -> Maybe a
Just [[Char]
"Group_Name should only contain alphanumeric characters and '_', '-', '.': " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
                                   Field -> [Char]
B.unpack (GroupName -> Field
unGroupName GroupName
groupName)]

instance Show GroupName where
    show :: GroupName -> [Char]
show (GroupName Field
x) = Field -> [Char]
B.unpack Field
x

instance Csv.ToField GroupName where
    toField :: GroupName -> Field
toField (GroupName Field
x) = Field -> Field
forall a. ToField a => a -> Field
Csv.toField Field
x

instance FromFieldVersioned GroupName where
    parseFieldVersioned :: PoseidonVersion -> Field -> Parser GroupName
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser GroupName
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Group_Name"

-- the IsString instance allows us to write GroupName "MyGroup" directly, mainly for testing purposes.
instance IsString GroupName where
    fromString :: [Char] -> GroupName
fromString [Char]
str = Field -> GroupName
GroupName ([Char] -> Field
B.pack [Char]
str)

-- | A datatype for the Individual_ID .janno column
newtype JannoIndividualID = JannoIndividualID T.Text deriving (JannoIndividualID -> JannoIndividualID -> Bool
(JannoIndividualID -> JannoIndividualID -> Bool)
-> (JannoIndividualID -> JannoIndividualID -> Bool)
-> Eq JannoIndividualID
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoIndividualID -> JannoIndividualID -> Bool
== :: JannoIndividualID -> JannoIndividualID -> Bool
$c/= :: JannoIndividualID -> JannoIndividualID -> Bool
/= :: JannoIndividualID -> JannoIndividualID -> Bool
Eq, Eq JannoIndividualID
Eq JannoIndividualID =>
(JannoIndividualID -> JannoIndividualID -> Ordering)
-> (JannoIndividualID -> JannoIndividualID -> Bool)
-> (JannoIndividualID -> JannoIndividualID -> Bool)
-> (JannoIndividualID -> JannoIndividualID -> Bool)
-> (JannoIndividualID -> JannoIndividualID -> Bool)
-> (JannoIndividualID -> JannoIndividualID -> JannoIndividualID)
-> (JannoIndividualID -> JannoIndividualID -> JannoIndividualID)
-> Ord JannoIndividualID
JannoIndividualID -> JannoIndividualID -> Bool
JannoIndividualID -> JannoIndividualID -> Ordering
JannoIndividualID -> JannoIndividualID -> JannoIndividualID
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
$ccompare :: JannoIndividualID -> JannoIndividualID -> Ordering
compare :: JannoIndividualID -> JannoIndividualID -> Ordering
$c< :: JannoIndividualID -> JannoIndividualID -> Bool
< :: JannoIndividualID -> JannoIndividualID -> Bool
$c<= :: JannoIndividualID -> JannoIndividualID -> Bool
<= :: JannoIndividualID -> JannoIndividualID -> Bool
$c> :: JannoIndividualID -> JannoIndividualID -> Bool
> :: JannoIndividualID -> JannoIndividualID -> Bool
$c>= :: JannoIndividualID -> JannoIndividualID -> Bool
>= :: JannoIndividualID -> JannoIndividualID -> Bool
$cmax :: JannoIndividualID -> JannoIndividualID -> JannoIndividualID
max :: JannoIndividualID -> JannoIndividualID -> JannoIndividualID
$cmin :: JannoIndividualID -> JannoIndividualID -> JannoIndividualID
min :: JannoIndividualID -> JannoIndividualID -> JannoIndividualID
Ord)
$(makeInstances ''JannoIndividualID "Individual_ID")

-- | A datatype for the Species .janno column
newtype JannoSpecies = JannoSpecies T.Text deriving (JannoSpecies -> JannoSpecies -> Bool
(JannoSpecies -> JannoSpecies -> Bool)
-> (JannoSpecies -> JannoSpecies -> Bool) -> Eq JannoSpecies
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoSpecies -> JannoSpecies -> Bool
== :: JannoSpecies -> JannoSpecies -> Bool
$c/= :: JannoSpecies -> JannoSpecies -> Bool
/= :: JannoSpecies -> JannoSpecies -> Bool
Eq, Eq JannoSpecies
Eq JannoSpecies =>
(JannoSpecies -> JannoSpecies -> Ordering)
-> (JannoSpecies -> JannoSpecies -> Bool)
-> (JannoSpecies -> JannoSpecies -> Bool)
-> (JannoSpecies -> JannoSpecies -> Bool)
-> (JannoSpecies -> JannoSpecies -> Bool)
-> (JannoSpecies -> JannoSpecies -> JannoSpecies)
-> (JannoSpecies -> JannoSpecies -> JannoSpecies)
-> Ord JannoSpecies
JannoSpecies -> JannoSpecies -> Bool
JannoSpecies -> JannoSpecies -> Ordering
JannoSpecies -> JannoSpecies -> JannoSpecies
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
$ccompare :: JannoSpecies -> JannoSpecies -> Ordering
compare :: JannoSpecies -> JannoSpecies -> Ordering
$c< :: JannoSpecies -> JannoSpecies -> Bool
< :: JannoSpecies -> JannoSpecies -> Bool
$c<= :: JannoSpecies -> JannoSpecies -> Bool
<= :: JannoSpecies -> JannoSpecies -> Bool
$c> :: JannoSpecies -> JannoSpecies -> Bool
> :: JannoSpecies -> JannoSpecies -> Bool
$c>= :: JannoSpecies -> JannoSpecies -> Bool
>= :: JannoSpecies -> JannoSpecies -> Bool
$cmax :: JannoSpecies -> JannoSpecies -> JannoSpecies
max :: JannoSpecies -> JannoSpecies -> JannoSpecies
$cmin :: JannoSpecies -> JannoSpecies -> JannoSpecies
min :: JannoSpecies -> JannoSpecies -> JannoSpecies
Ord)
$(makeInstances ''JannoSpecies "Species")

-- | A datatype for the Alternative_IDs .janno column
newtype JannoAlternativeID = JannoAlternativeID T.Text deriving (JannoAlternativeID -> JannoAlternativeID -> Bool
(JannoAlternativeID -> JannoAlternativeID -> Bool)
-> (JannoAlternativeID -> JannoAlternativeID -> Bool)
-> Eq JannoAlternativeID
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoAlternativeID -> JannoAlternativeID -> Bool
== :: JannoAlternativeID -> JannoAlternativeID -> Bool
$c/= :: JannoAlternativeID -> JannoAlternativeID -> Bool
/= :: JannoAlternativeID -> JannoAlternativeID -> Bool
Eq)
$(makeInstances ''JannoAlternativeID "Alternative_IDs")

-- | A datatype for the Alternative_IDs_Context .janno column
newtype JannoAlternativeIDContext = JannoAlternativeIDContext T.Text deriving (JannoAlternativeIDContext -> JannoAlternativeIDContext -> Bool
(JannoAlternativeIDContext -> JannoAlternativeIDContext -> Bool)
-> (JannoAlternativeIDContext -> JannoAlternativeIDContext -> Bool)
-> Eq JannoAlternativeIDContext
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoAlternativeIDContext -> JannoAlternativeIDContext -> Bool
== :: JannoAlternativeIDContext -> JannoAlternativeIDContext -> Bool
$c/= :: JannoAlternativeIDContext -> JannoAlternativeIDContext -> Bool
/= :: JannoAlternativeIDContext -> JannoAlternativeIDContext -> Bool
Eq)
$(makeInstances ''JannoAlternativeIDContext "Alternative_IDs_Context")

-- | A datatype for the Relation_To .janno column
newtype JannoRelationTo = JannoRelationTo T.Text deriving (JannoRelationTo -> JannoRelationTo -> Bool
(JannoRelationTo -> JannoRelationTo -> Bool)
-> (JannoRelationTo -> JannoRelationTo -> Bool)
-> Eq JannoRelationTo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoRelationTo -> JannoRelationTo -> Bool
== :: JannoRelationTo -> JannoRelationTo -> Bool
$c/= :: JannoRelationTo -> JannoRelationTo -> Bool
/= :: JannoRelationTo -> JannoRelationTo -> Bool
Eq)
$(makeInstances ''JannoRelationTo "Relation_To")

-- | A datatype for the Relation_Degree .janno column
data JannoRelationDegree =
      Identical
    | First
    | Second
    | ThirdToFifth
    | SixthToTenth
    | Unrelated
    | OtherDegree
    deriving (JannoRelationDegree -> JannoRelationDegree -> Bool
(JannoRelationDegree -> JannoRelationDegree -> Bool)
-> (JannoRelationDegree -> JannoRelationDegree -> Bool)
-> Eq JannoRelationDegree
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoRelationDegree -> JannoRelationDegree -> Bool
== :: JannoRelationDegree -> JannoRelationDegree -> Bool
$c/= :: JannoRelationDegree -> JannoRelationDegree -> Bool
/= :: JannoRelationDegree -> JannoRelationDegree -> Bool
Eq, Eq JannoRelationDegree
Eq JannoRelationDegree =>
(JannoRelationDegree -> JannoRelationDegree -> Ordering)
-> (JannoRelationDegree -> JannoRelationDegree -> Bool)
-> (JannoRelationDegree -> JannoRelationDegree -> Bool)
-> (JannoRelationDegree -> JannoRelationDegree -> Bool)
-> (JannoRelationDegree -> JannoRelationDegree -> Bool)
-> (JannoRelationDegree
    -> JannoRelationDegree -> JannoRelationDegree)
-> (JannoRelationDegree
    -> JannoRelationDegree -> JannoRelationDegree)
-> Ord JannoRelationDegree
JannoRelationDegree -> JannoRelationDegree -> Bool
JannoRelationDegree -> JannoRelationDegree -> Ordering
JannoRelationDegree -> JannoRelationDegree -> JannoRelationDegree
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
$ccompare :: JannoRelationDegree -> JannoRelationDegree -> Ordering
compare :: JannoRelationDegree -> JannoRelationDegree -> Ordering
$c< :: JannoRelationDegree -> JannoRelationDegree -> Bool
< :: JannoRelationDegree -> JannoRelationDegree -> Bool
$c<= :: JannoRelationDegree -> JannoRelationDegree -> Bool
<= :: JannoRelationDegree -> JannoRelationDegree -> Bool
$c> :: JannoRelationDegree -> JannoRelationDegree -> Bool
> :: JannoRelationDegree -> JannoRelationDegree -> Bool
$c>= :: JannoRelationDegree -> JannoRelationDegree -> Bool
>= :: JannoRelationDegree -> JannoRelationDegree -> Bool
$cmax :: JannoRelationDegree -> JannoRelationDegree -> JannoRelationDegree
max :: JannoRelationDegree -> JannoRelationDegree -> JannoRelationDegree
$cmin :: JannoRelationDegree -> JannoRelationDegree -> JannoRelationDegree
min :: JannoRelationDegree -> JannoRelationDegree -> JannoRelationDegree
Ord, (forall x. JannoRelationDegree -> Rep JannoRelationDegree x)
-> (forall x. Rep JannoRelationDegree x -> JannoRelationDegree)
-> Generic JannoRelationDegree
forall x. Rep JannoRelationDegree x -> JannoRelationDegree
forall x. JannoRelationDegree -> Rep JannoRelationDegree x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoRelationDegree -> Rep JannoRelationDegree x
from :: forall x. JannoRelationDegree -> Rep JannoRelationDegree x
$cto :: forall x. Rep JannoRelationDegree x -> JannoRelationDegree
to :: forall x. Rep JannoRelationDegree x -> JannoRelationDegree
Generic, Int -> JannoRelationDegree
JannoRelationDegree -> Int
JannoRelationDegree -> [JannoRelationDegree]
JannoRelationDegree -> JannoRelationDegree
JannoRelationDegree -> JannoRelationDegree -> [JannoRelationDegree]
JannoRelationDegree
-> JannoRelationDegree
-> JannoRelationDegree
-> [JannoRelationDegree]
(JannoRelationDegree -> JannoRelationDegree)
-> (JannoRelationDegree -> JannoRelationDegree)
-> (Int -> JannoRelationDegree)
-> (JannoRelationDegree -> Int)
-> (JannoRelationDegree -> [JannoRelationDegree])
-> (JannoRelationDegree
    -> JannoRelationDegree -> [JannoRelationDegree])
-> (JannoRelationDegree
    -> JannoRelationDegree -> [JannoRelationDegree])
-> (JannoRelationDegree
    -> JannoRelationDegree
    -> JannoRelationDegree
    -> [JannoRelationDegree])
-> Enum JannoRelationDegree
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: JannoRelationDegree -> JannoRelationDegree
succ :: JannoRelationDegree -> JannoRelationDegree
$cpred :: JannoRelationDegree -> JannoRelationDegree
pred :: JannoRelationDegree -> JannoRelationDegree
$ctoEnum :: Int -> JannoRelationDegree
toEnum :: Int -> JannoRelationDegree
$cfromEnum :: JannoRelationDegree -> Int
fromEnum :: JannoRelationDegree -> Int
$cenumFrom :: JannoRelationDegree -> [JannoRelationDegree]
enumFrom :: JannoRelationDegree -> [JannoRelationDegree]
$cenumFromThen :: JannoRelationDegree -> JannoRelationDegree -> [JannoRelationDegree]
enumFromThen :: JannoRelationDegree -> JannoRelationDegree -> [JannoRelationDegree]
$cenumFromTo :: JannoRelationDegree -> JannoRelationDegree -> [JannoRelationDegree]
enumFromTo :: JannoRelationDegree -> JannoRelationDegree -> [JannoRelationDegree]
$cenumFromThenTo :: JannoRelationDegree
-> JannoRelationDegree
-> JannoRelationDegree
-> [JannoRelationDegree]
enumFromThenTo :: JannoRelationDegree
-> JannoRelationDegree
-> JannoRelationDegree
-> [JannoRelationDegree]
Enum, JannoRelationDegree
JannoRelationDegree
-> JannoRelationDegree -> Bounded JannoRelationDegree
forall a. a -> a -> Bounded a
$cminBound :: JannoRelationDegree
minBound :: JannoRelationDegree
$cmaxBound :: JannoRelationDegree
maxBound :: JannoRelationDegree
Bounded)

instance Makeable JannoRelationDegree where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoRelationDegree
make PoseidonVersion
_ Text
x
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"identical"    = JannoRelationDegree -> m JannoRelationDegree
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoRelationDegree
Identical
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"first"        = JannoRelationDegree -> m JannoRelationDegree
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoRelationDegree
First
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"second"       = JannoRelationDegree -> m JannoRelationDegree
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoRelationDegree
Second
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"thirdToFifth" = JannoRelationDegree -> m JannoRelationDegree
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoRelationDegree
ThirdToFifth
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"sixthToTenth" = JannoRelationDegree -> m JannoRelationDegree
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoRelationDegree
SixthToTenth
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"unrelated"    = JannoRelationDegree -> m JannoRelationDegree
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoRelationDegree
Unrelated -- this should be omitted in the documentation
                                               -- relations of type "unrelated" don't have to be
                                               -- listed explicitly
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"other"        = JannoRelationDegree -> m JannoRelationDegree
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoRelationDegree
OtherDegree
        | Bool
otherwise           = [Char] -> m JannoRelationDegree
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoRelationDegree)
-> [Char] -> m JannoRelationDegree
forall a b. (a -> b) -> a -> b
$ [Char]
"Relation_Degree is set to " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
". " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
                                       [Char]
"That is not in the allowed set [identical, first, second, thirdToFifth, sixthToTenth, other]."
instance Suspicious JannoRelationDegree where inspect :: JannoRelationDegree -> Maybe [[Char]]
inspect JannoRelationDegree
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoRelationDegree where
    show :: JannoRelationDegree -> [Char]
show JannoRelationDegree
Identical    = [Char]
"identical"
    show JannoRelationDegree
First        = [Char]
"first"
    show JannoRelationDegree
Second       = [Char]
"second"
    show JannoRelationDegree
ThirdToFifth = [Char]
"thirdToFifth"
    show JannoRelationDegree
SixthToTenth = [Char]
"sixthToTenth"
    show JannoRelationDegree
Unrelated    = [Char]
"unrelated"
    show JannoRelationDegree
OtherDegree  = [Char]
"other"
instance Csv.ToField JannoRelationDegree where   toField :: JannoRelationDegree -> Field
toField JannoRelationDegree
x = [Char] -> Field
forall a. ToField a => a -> Field
Csv.toField ([Char] -> Field) -> [Char] -> Field
forall a b. (a -> b) -> a -> b
$ JannoRelationDegree -> [Char]
forall a. Show a => a -> [Char]
show JannoRelationDegree
x
instance FromFieldVersioned JannoRelationDegree where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoRelationDegree
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoRelationDegree
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Relation_Degree"

-- | A datatype for the Relation_Type .janno column
newtype JannoRelationType = JannoRelationType T.Text deriving (JannoRelationType -> JannoRelationType -> Bool
(JannoRelationType -> JannoRelationType -> Bool)
-> (JannoRelationType -> JannoRelationType -> Bool)
-> Eq JannoRelationType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoRelationType -> JannoRelationType -> Bool
== :: JannoRelationType -> JannoRelationType -> Bool
$c/= :: JannoRelationType -> JannoRelationType -> Bool
/= :: JannoRelationType -> JannoRelationType -> Bool
Eq)
$(makeInstances ''JannoRelationType "Relation_Type")

-- | A datatype for the Collection_ID .janno column
newtype JannoCollectionID = JannoCollectionID T.Text deriving (JannoCollectionID -> JannoCollectionID -> Bool
(JannoCollectionID -> JannoCollectionID -> Bool)
-> (JannoCollectionID -> JannoCollectionID -> Bool)
-> Eq JannoCollectionID
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoCollectionID -> JannoCollectionID -> Bool
== :: JannoCollectionID -> JannoCollectionID -> Bool
$c/= :: JannoCollectionID -> JannoCollectionID -> Bool
/= :: JannoCollectionID -> JannoCollectionID -> Bool
Eq)
$(makeInstances ''JannoCollectionID "Collection_ID")

-- | A datatype for the Custodian_Institution .janno column
newtype JannoCustodianInstitution = JannoCustodianInstitution T.Text deriving (JannoCustodianInstitution -> JannoCustodianInstitution -> Bool
(JannoCustodianInstitution -> JannoCustodianInstitution -> Bool)
-> (JannoCustodianInstitution -> JannoCustodianInstitution -> Bool)
-> Eq JannoCustodianInstitution
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoCustodianInstitution -> JannoCustodianInstitution -> Bool
== :: JannoCustodianInstitution -> JannoCustodianInstitution -> Bool
$c/= :: JannoCustodianInstitution -> JannoCustodianInstitution -> Bool
/= :: JannoCustodianInstitution -> JannoCustodianInstitution -> Bool
Eq)
$(makeInstances ''JannoCustodianInstitution "Custodian_Institution")

-- | A datatype for the Cultural_Era .janno column
newtype JannoCulturalEra = JannoCulturalEra T.Text deriving (JannoCulturalEra -> JannoCulturalEra -> Bool
(JannoCulturalEra -> JannoCulturalEra -> Bool)
-> (JannoCulturalEra -> JannoCulturalEra -> Bool)
-> Eq JannoCulturalEra
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoCulturalEra -> JannoCulturalEra -> Bool
== :: JannoCulturalEra -> JannoCulturalEra -> Bool
$c/= :: JannoCulturalEra -> JannoCulturalEra -> Bool
/= :: JannoCulturalEra -> JannoCulturalEra -> Bool
Eq)
$(makeInstances ''JannoCulturalEra "Cultural_Era")

-- | A datatype for the Cultural_Era_URL .janno column
newtype JannoCulturalEraURL = JannoCulturalEraURL T.Text deriving (JannoCulturalEraURL -> JannoCulturalEraURL -> Bool
(JannoCulturalEraURL -> JannoCulturalEraURL -> Bool)
-> (JannoCulturalEraURL -> JannoCulturalEraURL -> Bool)
-> Eq JannoCulturalEraURL
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoCulturalEraURL -> JannoCulturalEraURL -> Bool
== :: JannoCulturalEraURL -> JannoCulturalEraURL -> Bool
$c/= :: JannoCulturalEraURL -> JannoCulturalEraURL -> Bool
/= :: JannoCulturalEraURL -> JannoCulturalEraURL -> Bool
Eq, Eq JannoCulturalEraURL
Eq JannoCulturalEraURL =>
(JannoCulturalEraURL -> JannoCulturalEraURL -> Ordering)
-> (JannoCulturalEraURL -> JannoCulturalEraURL -> Bool)
-> (JannoCulturalEraURL -> JannoCulturalEraURL -> Bool)
-> (JannoCulturalEraURL -> JannoCulturalEraURL -> Bool)
-> (JannoCulturalEraURL -> JannoCulturalEraURL -> Bool)
-> (JannoCulturalEraURL
    -> JannoCulturalEraURL -> JannoCulturalEraURL)
-> (JannoCulturalEraURL
    -> JannoCulturalEraURL -> JannoCulturalEraURL)
-> Ord JannoCulturalEraURL
JannoCulturalEraURL -> JannoCulturalEraURL -> Bool
JannoCulturalEraURL -> JannoCulturalEraURL -> Ordering
JannoCulturalEraURL -> JannoCulturalEraURL -> JannoCulturalEraURL
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
$ccompare :: JannoCulturalEraURL -> JannoCulturalEraURL -> Ordering
compare :: JannoCulturalEraURL -> JannoCulturalEraURL -> Ordering
$c< :: JannoCulturalEraURL -> JannoCulturalEraURL -> Bool
< :: JannoCulturalEraURL -> JannoCulturalEraURL -> Bool
$c<= :: JannoCulturalEraURL -> JannoCulturalEraURL -> Bool
<= :: JannoCulturalEraURL -> JannoCulturalEraURL -> Bool
$c> :: JannoCulturalEraURL -> JannoCulturalEraURL -> Bool
> :: JannoCulturalEraURL -> JannoCulturalEraURL -> Bool
$c>= :: JannoCulturalEraURL -> JannoCulturalEraURL -> Bool
>= :: JannoCulturalEraURL -> JannoCulturalEraURL -> Bool
$cmax :: JannoCulturalEraURL -> JannoCulturalEraURL -> JannoCulturalEraURL
max :: JannoCulturalEraURL -> JannoCulturalEraURL -> JannoCulturalEraURL
$cmin :: JannoCulturalEraURL -> JannoCulturalEraURL -> JannoCulturalEraURL
min :: JannoCulturalEraURL -> JannoCulturalEraURL -> JannoCulturalEraURL
Ord, (forall x. JannoCulturalEraURL -> Rep JannoCulturalEraURL x)
-> (forall x. Rep JannoCulturalEraURL x -> JannoCulturalEraURL)
-> Generic JannoCulturalEraURL
forall x. Rep JannoCulturalEraURL x -> JannoCulturalEraURL
forall x. JannoCulturalEraURL -> Rep JannoCulturalEraURL x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoCulturalEraURL -> Rep JannoCulturalEraURL x
from :: forall x. JannoCulturalEraURL -> Rep JannoCulturalEraURL x
$cto :: forall x. Rep JannoCulturalEraURL x -> JannoCulturalEraURL
to :: forall x. Rep JannoCulturalEraURL x -> JannoCulturalEraURL
Generic)

instance Makeable JannoCulturalEraURL where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoCulturalEraURL
make PoseidonVersion
_ Text
x
        | [Char] -> Bool
isURIReference (Text -> [Char]
T.unpack Text
x) = JannoCulturalEraURL -> m JannoCulturalEraURL
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (JannoCulturalEraURL -> m JannoCulturalEraURL)
-> JannoCulturalEraURL -> m JannoCulturalEraURL
forall a b. (a -> b) -> a -> b
$ Text -> JannoCulturalEraURL
JannoCulturalEraURL Text
x
        | Bool
otherwise                   = [Char] -> m JannoCulturalEraURL
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoCulturalEraURL)
-> [Char] -> m JannoCulturalEraURL
forall a b. (a -> b) -> a -> b
$ [Char]
"Cultural_Era_URL " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" is not a well structured URI."
instance Suspicious JannoCulturalEraURL where
    inspect :: JannoCulturalEraURL -> Maybe [[Char]]
inspect (JannoCulturalEraURL Text
x)
        | Text -> Text -> Bool
T.isInfixOf Text
"n2t.net/ark" Text
x = Maybe [[Char]]
forall a. Maybe a
Nothing
        | Text -> Text -> Bool
T.isInfixOf Text
"chronontology.dainst.org/period" Text
x = Maybe [[Char]]
forall a. Maybe a
Nothing
        | Bool
otherwise = [[Char]] -> Maybe [[Char]]
forall a. a -> Maybe a
Just [[Char]
"Archaeological_Culture_URL " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" probably not a valid PeriodO \
                            \or ChronOntology permalink."]
instance Show JannoCulturalEraURL where          show :: JannoCulturalEraURL -> [Char]
show (JannoCulturalEraURL Text
x) = Text -> [Char]
T.unpack Text
x
instance Csv.ToField JannoCulturalEraURL where   toField :: JannoCulturalEraURL -> Field
toField (JannoCulturalEraURL Text
x) = Text -> Field
forall a. ToField a => a -> Field
Csv.toField Text
x
instance FromFieldVersioned JannoCulturalEraURL where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoCulturalEraURL
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoCulturalEraURL
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Cultural_Era_URL"

-- | A datatype for the Archaeological_Culture .janno column
newtype JannoArchaeologicalCulture = JannoArchaeologicalCulture T.Text deriving (JannoArchaeologicalCulture -> JannoArchaeologicalCulture -> Bool
(JannoArchaeologicalCulture -> JannoArchaeologicalCulture -> Bool)
-> (JannoArchaeologicalCulture
    -> JannoArchaeologicalCulture -> Bool)
-> Eq JannoArchaeologicalCulture
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoArchaeologicalCulture -> JannoArchaeologicalCulture -> Bool
== :: JannoArchaeologicalCulture -> JannoArchaeologicalCulture -> Bool
$c/= :: JannoArchaeologicalCulture -> JannoArchaeologicalCulture -> Bool
/= :: JannoArchaeologicalCulture -> JannoArchaeologicalCulture -> Bool
Eq)
$(makeInstances ''JannoArchaeologicalCulture "Archaeological_Culture")

-- | A datatype for the Archaeological_Culture_URL .janno column
newtype JannoArchaeologicalCultureURL = JannoArchaeologicalCultureURL T.Text deriving (JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> Bool
(JannoArchaeologicalCultureURL
 -> JannoArchaeologicalCultureURL -> Bool)
-> (JannoArchaeologicalCultureURL
    -> JannoArchaeologicalCultureURL -> Bool)
-> Eq JannoArchaeologicalCultureURL
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> Bool
== :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> Bool
$c/= :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> Bool
/= :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> Bool
Eq, Eq JannoArchaeologicalCultureURL
Eq JannoArchaeologicalCultureURL =>
(JannoArchaeologicalCultureURL
 -> JannoArchaeologicalCultureURL -> Ordering)
-> (JannoArchaeologicalCultureURL
    -> JannoArchaeologicalCultureURL -> Bool)
-> (JannoArchaeologicalCultureURL
    -> JannoArchaeologicalCultureURL -> Bool)
-> (JannoArchaeologicalCultureURL
    -> JannoArchaeologicalCultureURL -> Bool)
-> (JannoArchaeologicalCultureURL
    -> JannoArchaeologicalCultureURL -> Bool)
-> (JannoArchaeologicalCultureURL
    -> JannoArchaeologicalCultureURL -> JannoArchaeologicalCultureURL)
-> (JannoArchaeologicalCultureURL
    -> JannoArchaeologicalCultureURL -> JannoArchaeologicalCultureURL)
-> Ord JannoArchaeologicalCultureURL
JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> Bool
JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> Ordering
JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> JannoArchaeologicalCultureURL
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
$ccompare :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> Ordering
compare :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> Ordering
$c< :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> Bool
< :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> Bool
$c<= :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> Bool
<= :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> Bool
$c> :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> Bool
> :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> Bool
$c>= :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> Bool
>= :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> Bool
$cmax :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> JannoArchaeologicalCultureURL
max :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> JannoArchaeologicalCultureURL
$cmin :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> JannoArchaeologicalCultureURL
min :: JannoArchaeologicalCultureURL
-> JannoArchaeologicalCultureURL -> JannoArchaeologicalCultureURL
Ord, (forall x.
 JannoArchaeologicalCultureURL
 -> Rep JannoArchaeologicalCultureURL x)
-> (forall x.
    Rep JannoArchaeologicalCultureURL x
    -> JannoArchaeologicalCultureURL)
-> Generic JannoArchaeologicalCultureURL
forall x.
Rep JannoArchaeologicalCultureURL x
-> JannoArchaeologicalCultureURL
forall x.
JannoArchaeologicalCultureURL
-> Rep JannoArchaeologicalCultureURL x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
JannoArchaeologicalCultureURL
-> Rep JannoArchaeologicalCultureURL x
from :: forall x.
JannoArchaeologicalCultureURL
-> Rep JannoArchaeologicalCultureURL x
$cto :: forall x.
Rep JannoArchaeologicalCultureURL x
-> JannoArchaeologicalCultureURL
to :: forall x.
Rep JannoArchaeologicalCultureURL x
-> JannoArchaeologicalCultureURL
Generic)

instance Makeable JannoArchaeologicalCultureURL where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoArchaeologicalCultureURL
make PoseidonVersion
_ Text
x
        | [Char] -> Bool
isURIReference (Text -> [Char]
T.unpack Text
x) = JannoArchaeologicalCultureURL -> m JannoArchaeologicalCultureURL
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (JannoArchaeologicalCultureURL -> m JannoArchaeologicalCultureURL)
-> JannoArchaeologicalCultureURL -> m JannoArchaeologicalCultureURL
forall a b. (a -> b) -> a -> b
$ Text -> JannoArchaeologicalCultureURL
JannoArchaeologicalCultureURL Text
x
        | Bool
otherwise                   = [Char] -> m JannoArchaeologicalCultureURL
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoArchaeologicalCultureURL)
-> [Char] -> m JannoArchaeologicalCultureURL
forall a b. (a -> b) -> a -> b
$ [Char]
"Archaeological_Culture_URL " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" is not a well structured URI."
instance Suspicious JannoArchaeologicalCultureURL where
    inspect :: JannoArchaeologicalCultureURL -> Maybe [[Char]]
inspect (JannoArchaeologicalCultureURL Text
x)
        | Text -> Text -> Bool
T.isInfixOf Text
"n2t.net/ark" Text
x = Maybe [[Char]]
forall a. Maybe a
Nothing
        | Text -> Text -> Bool
T.isInfixOf Text
"chronontology.dainst.org/period" Text
x = Maybe [[Char]]
forall a. Maybe a
Nothing
        | Bool
otherwise = [[Char]] -> Maybe [[Char]]
forall a. a -> Maybe a
Just [[Char]
"Archaeological_Culture_URL " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" probably not a valid PeriodO \
                            \or ChronOntology permalink."]
instance Show JannoArchaeologicalCultureURL where          show :: JannoArchaeologicalCultureURL -> [Char]
show (JannoArchaeologicalCultureURL Text
x) = Text -> [Char]
T.unpack Text
x
instance Csv.ToField JannoArchaeologicalCultureURL where   toField :: JannoArchaeologicalCultureURL -> Field
toField (JannoArchaeologicalCultureURL Text
x) = Text -> Field
forall a. ToField a => a -> Field
Csv.toField Text
x
instance FromFieldVersioned JannoArchaeologicalCultureURL where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoArchaeologicalCultureURL
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion
-> [Char] -> Field -> Parser JannoArchaeologicalCultureURL
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Archaeological_Culture_URL"

-- | A datatype for the Country .janno column
newtype JannoCountry = JannoCountry T.Text deriving (JannoCountry -> JannoCountry -> Bool
(JannoCountry -> JannoCountry -> Bool)
-> (JannoCountry -> JannoCountry -> Bool) -> Eq JannoCountry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoCountry -> JannoCountry -> Bool
== :: JannoCountry -> JannoCountry -> Bool
$c/= :: JannoCountry -> JannoCountry -> Bool
/= :: JannoCountry -> JannoCountry -> Bool
Eq, Eq JannoCountry
Eq JannoCountry =>
(JannoCountry -> JannoCountry -> Ordering)
-> (JannoCountry -> JannoCountry -> Bool)
-> (JannoCountry -> JannoCountry -> Bool)
-> (JannoCountry -> JannoCountry -> Bool)
-> (JannoCountry -> JannoCountry -> Bool)
-> (JannoCountry -> JannoCountry -> JannoCountry)
-> (JannoCountry -> JannoCountry -> JannoCountry)
-> Ord JannoCountry
JannoCountry -> JannoCountry -> Bool
JannoCountry -> JannoCountry -> Ordering
JannoCountry -> JannoCountry -> JannoCountry
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
$ccompare :: JannoCountry -> JannoCountry -> Ordering
compare :: JannoCountry -> JannoCountry -> Ordering
$c< :: JannoCountry -> JannoCountry -> Bool
< :: JannoCountry -> JannoCountry -> Bool
$c<= :: JannoCountry -> JannoCountry -> Bool
<= :: JannoCountry -> JannoCountry -> Bool
$c> :: JannoCountry -> JannoCountry -> Bool
> :: JannoCountry -> JannoCountry -> Bool
$c>= :: JannoCountry -> JannoCountry -> Bool
>= :: JannoCountry -> JannoCountry -> Bool
$cmax :: JannoCountry -> JannoCountry -> JannoCountry
max :: JannoCountry -> JannoCountry -> JannoCountry
$cmin :: JannoCountry -> JannoCountry -> JannoCountry
min :: JannoCountry -> JannoCountry -> JannoCountry
Ord)
$(makeInstances ''JannoCountry "Country")

-- | A datatype for countries in ISO-alpha2 code format
newtype JannoCountryISO = JannoCountryISO Country deriving (JannoCountryISO -> JannoCountryISO -> Bool
(JannoCountryISO -> JannoCountryISO -> Bool)
-> (JannoCountryISO -> JannoCountryISO -> Bool)
-> Eq JannoCountryISO
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoCountryISO -> JannoCountryISO -> Bool
== :: JannoCountryISO -> JannoCountryISO -> Bool
$c/= :: JannoCountryISO -> JannoCountryISO -> Bool
/= :: JannoCountryISO -> JannoCountryISO -> Bool
Eq, Eq JannoCountryISO
Eq JannoCountryISO =>
(JannoCountryISO -> JannoCountryISO -> Ordering)
-> (JannoCountryISO -> JannoCountryISO -> Bool)
-> (JannoCountryISO -> JannoCountryISO -> Bool)
-> (JannoCountryISO -> JannoCountryISO -> Bool)
-> (JannoCountryISO -> JannoCountryISO -> Bool)
-> (JannoCountryISO -> JannoCountryISO -> JannoCountryISO)
-> (JannoCountryISO -> JannoCountryISO -> JannoCountryISO)
-> Ord JannoCountryISO
JannoCountryISO -> JannoCountryISO -> Bool
JannoCountryISO -> JannoCountryISO -> Ordering
JannoCountryISO -> JannoCountryISO -> JannoCountryISO
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
$ccompare :: JannoCountryISO -> JannoCountryISO -> Ordering
compare :: JannoCountryISO -> JannoCountryISO -> Ordering
$c< :: JannoCountryISO -> JannoCountryISO -> Bool
< :: JannoCountryISO -> JannoCountryISO -> Bool
$c<= :: JannoCountryISO -> JannoCountryISO -> Bool
<= :: JannoCountryISO -> JannoCountryISO -> Bool
$c> :: JannoCountryISO -> JannoCountryISO -> Bool
> :: JannoCountryISO -> JannoCountryISO -> Bool
$c>= :: JannoCountryISO -> JannoCountryISO -> Bool
>= :: JannoCountryISO -> JannoCountryISO -> Bool
$cmax :: JannoCountryISO -> JannoCountryISO -> JannoCountryISO
max :: JannoCountryISO -> JannoCountryISO -> JannoCountryISO
$cmin :: JannoCountryISO -> JannoCountryISO -> JannoCountryISO
min :: JannoCountryISO -> JannoCountryISO -> JannoCountryISO
Ord)

instance Show JannoCountryISO where
    show :: JannoCountryISO -> [Char]
show (JannoCountryISO Country
x) = Text -> [Char]
T.unpack (Text -> [Char]) -> Text -> [Char]
forall a b. (a -> b) -> a -> b
$ Country -> Text
alphaTwoUpper Country
x
instance Makeable JannoCountryISO where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoCountryISO
make PoseidonVersion
_ Text
x = case Text -> Maybe Country
decodeAlphaTwo Text
x of
        Maybe Country
Nothing -> [Char] -> m JannoCountryISO
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoCountryISO) -> [Char] -> m JannoCountryISO
forall a b. (a -> b) -> a -> b
$
            [Char]
"Country_ISO is set to " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
". " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
            [Char]
"That is not a valid ISO-alpha2 code describing an existing country."
        Just Country
c  -> JannoCountryISO -> m JannoCountryISO
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (JannoCountryISO -> m JannoCountryISO)
-> JannoCountryISO -> m JannoCountryISO
forall a b. (a -> b) -> a -> b
$ Country -> JannoCountryISO
JannoCountryISO Country
c
instance Suspicious JannoCountryISO where inspect :: JannoCountryISO -> Maybe [[Char]]
inspect JannoCountryISO
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Csv.ToField JannoCountryISO where   toField :: JannoCountryISO -> Field
toField JannoCountryISO
x = [Char] -> Field
forall a. ToField a => a -> Field
Csv.toField ([Char] -> Field) -> [Char] -> Field
forall a b. (a -> b) -> a -> b
$ JannoCountryISO -> [Char]
forall a. Show a => a -> [Char]
show JannoCountryISO
x
instance FromFieldVersioned JannoCountryISO where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoCountryISO
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoCountryISO
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Country_ISO"

-- | A datatype for the Location .janno column
newtype JannoLocation = JannoLocation T.Text deriving (JannoLocation -> JannoLocation -> Bool
(JannoLocation -> JannoLocation -> Bool)
-> (JannoLocation -> JannoLocation -> Bool) -> Eq JannoLocation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoLocation -> JannoLocation -> Bool
== :: JannoLocation -> JannoLocation -> Bool
$c/= :: JannoLocation -> JannoLocation -> Bool
/= :: JannoLocation -> JannoLocation -> Bool
Eq)
$(makeInstances ''JannoLocation "Location")

-- | A datatype for the Site .janno column
newtype JannoSite = JannoSite T.Text deriving (JannoSite -> JannoSite -> Bool
(JannoSite -> JannoSite -> Bool)
-> (JannoSite -> JannoSite -> Bool) -> Eq JannoSite
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoSite -> JannoSite -> Bool
== :: JannoSite -> JannoSite -> Bool
$c/= :: JannoSite -> JannoSite -> Bool
/= :: JannoSite -> JannoSite -> Bool
Eq, Eq JannoSite
Eq JannoSite =>
(JannoSite -> JannoSite -> Ordering)
-> (JannoSite -> JannoSite -> Bool)
-> (JannoSite -> JannoSite -> Bool)
-> (JannoSite -> JannoSite -> Bool)
-> (JannoSite -> JannoSite -> Bool)
-> (JannoSite -> JannoSite -> JannoSite)
-> (JannoSite -> JannoSite -> JannoSite)
-> Ord JannoSite
JannoSite -> JannoSite -> Bool
JannoSite -> JannoSite -> Ordering
JannoSite -> JannoSite -> JannoSite
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
$ccompare :: JannoSite -> JannoSite -> Ordering
compare :: JannoSite -> JannoSite -> Ordering
$c< :: JannoSite -> JannoSite -> Bool
< :: JannoSite -> JannoSite -> Bool
$c<= :: JannoSite -> JannoSite -> Bool
<= :: JannoSite -> JannoSite -> Bool
$c> :: JannoSite -> JannoSite -> Bool
> :: JannoSite -> JannoSite -> Bool
$c>= :: JannoSite -> JannoSite -> Bool
>= :: JannoSite -> JannoSite -> Bool
$cmax :: JannoSite -> JannoSite -> JannoSite
max :: JannoSite -> JannoSite -> JannoSite
$cmin :: JannoSite -> JannoSite -> JannoSite
min :: JannoSite -> JannoSite -> JannoSite
Ord)
$(makeInstances ''JannoSite "Site")

-- | A datatype for the Latitude .janno column
newtype JannoLatitude = JannoLatitude Double deriving (JannoLatitude -> JannoLatitude -> Bool
(JannoLatitude -> JannoLatitude -> Bool)
-> (JannoLatitude -> JannoLatitude -> Bool) -> Eq JannoLatitude
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoLatitude -> JannoLatitude -> Bool
== :: JannoLatitude -> JannoLatitude -> Bool
$c/= :: JannoLatitude -> JannoLatitude -> Bool
/= :: JannoLatitude -> JannoLatitude -> Bool
Eq, Eq JannoLatitude
Eq JannoLatitude =>
(JannoLatitude -> JannoLatitude -> Ordering)
-> (JannoLatitude -> JannoLatitude -> Bool)
-> (JannoLatitude -> JannoLatitude -> Bool)
-> (JannoLatitude -> JannoLatitude -> Bool)
-> (JannoLatitude -> JannoLatitude -> Bool)
-> (JannoLatitude -> JannoLatitude -> JannoLatitude)
-> (JannoLatitude -> JannoLatitude -> JannoLatitude)
-> Ord JannoLatitude
JannoLatitude -> JannoLatitude -> Bool
JannoLatitude -> JannoLatitude -> Ordering
JannoLatitude -> JannoLatitude -> JannoLatitude
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
$ccompare :: JannoLatitude -> JannoLatitude -> Ordering
compare :: JannoLatitude -> JannoLatitude -> Ordering
$c< :: JannoLatitude -> JannoLatitude -> Bool
< :: JannoLatitude -> JannoLatitude -> Bool
$c<= :: JannoLatitude -> JannoLatitude -> Bool
<= :: JannoLatitude -> JannoLatitude -> Bool
$c> :: JannoLatitude -> JannoLatitude -> Bool
> :: JannoLatitude -> JannoLatitude -> Bool
$c>= :: JannoLatitude -> JannoLatitude -> Bool
>= :: JannoLatitude -> JannoLatitude -> Bool
$cmax :: JannoLatitude -> JannoLatitude -> JannoLatitude
max :: JannoLatitude -> JannoLatitude -> JannoLatitude
$cmin :: JannoLatitude -> JannoLatitude -> JannoLatitude
min :: JannoLatitude -> JannoLatitude -> JannoLatitude
Ord, (forall x. JannoLatitude -> Rep JannoLatitude x)
-> (forall x. Rep JannoLatitude x -> JannoLatitude)
-> Generic JannoLatitude
forall x. Rep JannoLatitude x -> JannoLatitude
forall x. JannoLatitude -> Rep JannoLatitude x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoLatitude -> Rep JannoLatitude x
from :: forall x. JannoLatitude -> Rep JannoLatitude x
$cto :: forall x. Rep JannoLatitude x -> JannoLatitude
to :: forall x. Rep JannoLatitude x -> JannoLatitude
Generic)

instance Makeable JannoLatitude where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoLatitude
make PoseidonVersion
_ Text
x =
        case Reader Double
T.double Text
x of
            Left [Char]
e -> [Char] -> m JannoLatitude
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoLatitude) -> [Char] -> m JannoLatitude
forall a b. (a -> b) -> a -> b
$ [Char]
"Latitude can not be converted to Double because " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
e
            Right (Double
num, Text
"") ->
                if Double
num Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= -Double
90 Bool -> Bool -> Bool
&& Double
num Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<= Double
90
                then JannoLatitude -> m JannoLatitude
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> JannoLatitude
JannoLatitude Double
num)
                else [Char] -> m JannoLatitude
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoLatitude) -> [Char] -> m JannoLatitude
forall a b. (a -> b) -> a -> b
$ [Char]
"Latitude " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" not between -90 and 90"
            Right (Double
_, Text
rest) -> [Char] -> m JannoLatitude
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoLatitude) -> [Char] -> m JannoLatitude
forall a b. (a -> b) -> a -> b
$ [Char]
"Latitude can not be converted to Double, because of a trailing " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
rest
instance Suspicious JannoLatitude where inspect :: JannoLatitude -> Maybe [[Char]]
inspect JannoLatitude
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoLatitude where          show :: JannoLatitude -> [Char]
show (JannoLatitude Double
x) = Double -> [Char]
forall a. Show a => a -> [Char]
show Double
x
instance Csv.ToField JannoLatitude where   toField :: JannoLatitude -> Field
toField (JannoLatitude Double
x) = Double -> Field
forall a. ToField a => a -> Field
Csv.toField Double
x
instance FromFieldVersioned JannoLatitude where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoLatitude
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoLatitude
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Latitude"

-- | A datatype for the Longitude .janno column
newtype JannoLongitude = JannoLongitude Double deriving (JannoLongitude -> JannoLongitude -> Bool
(JannoLongitude -> JannoLongitude -> Bool)
-> (JannoLongitude -> JannoLongitude -> Bool) -> Eq JannoLongitude
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoLongitude -> JannoLongitude -> Bool
== :: JannoLongitude -> JannoLongitude -> Bool
$c/= :: JannoLongitude -> JannoLongitude -> Bool
/= :: JannoLongitude -> JannoLongitude -> Bool
Eq, Eq JannoLongitude
Eq JannoLongitude =>
(JannoLongitude -> JannoLongitude -> Ordering)
-> (JannoLongitude -> JannoLongitude -> Bool)
-> (JannoLongitude -> JannoLongitude -> Bool)
-> (JannoLongitude -> JannoLongitude -> Bool)
-> (JannoLongitude -> JannoLongitude -> Bool)
-> (JannoLongitude -> JannoLongitude -> JannoLongitude)
-> (JannoLongitude -> JannoLongitude -> JannoLongitude)
-> Ord JannoLongitude
JannoLongitude -> JannoLongitude -> Bool
JannoLongitude -> JannoLongitude -> Ordering
JannoLongitude -> JannoLongitude -> JannoLongitude
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
$ccompare :: JannoLongitude -> JannoLongitude -> Ordering
compare :: JannoLongitude -> JannoLongitude -> Ordering
$c< :: JannoLongitude -> JannoLongitude -> Bool
< :: JannoLongitude -> JannoLongitude -> Bool
$c<= :: JannoLongitude -> JannoLongitude -> Bool
<= :: JannoLongitude -> JannoLongitude -> Bool
$c> :: JannoLongitude -> JannoLongitude -> Bool
> :: JannoLongitude -> JannoLongitude -> Bool
$c>= :: JannoLongitude -> JannoLongitude -> Bool
>= :: JannoLongitude -> JannoLongitude -> Bool
$cmax :: JannoLongitude -> JannoLongitude -> JannoLongitude
max :: JannoLongitude -> JannoLongitude -> JannoLongitude
$cmin :: JannoLongitude -> JannoLongitude -> JannoLongitude
min :: JannoLongitude -> JannoLongitude -> JannoLongitude
Ord, (forall x. JannoLongitude -> Rep JannoLongitude x)
-> (forall x. Rep JannoLongitude x -> JannoLongitude)
-> Generic JannoLongitude
forall x. Rep JannoLongitude x -> JannoLongitude
forall x. JannoLongitude -> Rep JannoLongitude x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoLongitude -> Rep JannoLongitude x
from :: forall x. JannoLongitude -> Rep JannoLongitude x
$cto :: forall x. Rep JannoLongitude x -> JannoLongitude
to :: forall x. Rep JannoLongitude x -> JannoLongitude
Generic)

instance Makeable JannoLongitude where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoLongitude
make PoseidonVersion
_ Text
x =
        case Reader Double
T.double Text
x of
            Left [Char]
e -> [Char] -> m JannoLongitude
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoLongitude) -> [Char] -> m JannoLongitude
forall a b. (a -> b) -> a -> b
$ [Char]
"Longitude can not be converted to Double because " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
e
            Right (Double
num, Text
"") ->
                if Double
num Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= -Double
180 Bool -> Bool -> Bool
&& Double
num Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<= Double
180
                then JannoLongitude -> m JannoLongitude
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> JannoLongitude
JannoLongitude Double
num)
                else [Char] -> m JannoLongitude
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoLongitude) -> [Char] -> m JannoLongitude
forall a b. (a -> b) -> a -> b
$ [Char]
"Longitude " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" not between -180 and 180"
            Right (Double
_, Text
rest) -> [Char] -> m JannoLongitude
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoLongitude) -> [Char] -> m JannoLongitude
forall a b. (a -> b) -> a -> b
$ [Char]
"Longitude can not be converted to Double, because of a trailing " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
rest
instance Suspicious JannoLongitude where inspect :: JannoLongitude -> Maybe [[Char]]
inspect JannoLongitude
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoLongitude where          show :: JannoLongitude -> [Char]
show (JannoLongitude Double
x) = Double -> [Char]
forall a. Show a => a -> [Char]
show Double
x
instance Csv.ToField JannoLongitude where   toField :: JannoLongitude -> Field
toField (JannoLongitude Double
x) = Double -> Field
forall a. ToField a => a -> Field
Csv.toField Double
x
instance FromFieldVersioned JannoLongitude where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoLongitude
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoLongitude
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Longitude"

-- | A datatype for the Date_Type .janno column
data JannoDateType =
      C14
    | Contextual
    | Modern
    deriving (JannoDateType -> JannoDateType -> Bool
(JannoDateType -> JannoDateType -> Bool)
-> (JannoDateType -> JannoDateType -> Bool) -> Eq JannoDateType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoDateType -> JannoDateType -> Bool
== :: JannoDateType -> JannoDateType -> Bool
$c/= :: JannoDateType -> JannoDateType -> Bool
/= :: JannoDateType -> JannoDateType -> Bool
Eq, Eq JannoDateType
Eq JannoDateType =>
(JannoDateType -> JannoDateType -> Ordering)
-> (JannoDateType -> JannoDateType -> Bool)
-> (JannoDateType -> JannoDateType -> Bool)
-> (JannoDateType -> JannoDateType -> Bool)
-> (JannoDateType -> JannoDateType -> Bool)
-> (JannoDateType -> JannoDateType -> JannoDateType)
-> (JannoDateType -> JannoDateType -> JannoDateType)
-> Ord JannoDateType
JannoDateType -> JannoDateType -> Bool
JannoDateType -> JannoDateType -> Ordering
JannoDateType -> JannoDateType -> JannoDateType
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
$ccompare :: JannoDateType -> JannoDateType -> Ordering
compare :: JannoDateType -> JannoDateType -> Ordering
$c< :: JannoDateType -> JannoDateType -> Bool
< :: JannoDateType -> JannoDateType -> Bool
$c<= :: JannoDateType -> JannoDateType -> Bool
<= :: JannoDateType -> JannoDateType -> Bool
$c> :: JannoDateType -> JannoDateType -> Bool
> :: JannoDateType -> JannoDateType -> Bool
$c>= :: JannoDateType -> JannoDateType -> Bool
>= :: JannoDateType -> JannoDateType -> Bool
$cmax :: JannoDateType -> JannoDateType -> JannoDateType
max :: JannoDateType -> JannoDateType -> JannoDateType
$cmin :: JannoDateType -> JannoDateType -> JannoDateType
min :: JannoDateType -> JannoDateType -> JannoDateType
Ord, (forall x. JannoDateType -> Rep JannoDateType x)
-> (forall x. Rep JannoDateType x -> JannoDateType)
-> Generic JannoDateType
forall x. Rep JannoDateType x -> JannoDateType
forall x. JannoDateType -> Rep JannoDateType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoDateType -> Rep JannoDateType x
from :: forall x. JannoDateType -> Rep JannoDateType x
$cto :: forall x. Rep JannoDateType x -> JannoDateType
to :: forall x. Rep JannoDateType x -> JannoDateType
Generic, Int -> JannoDateType
JannoDateType -> Int
JannoDateType -> [JannoDateType]
JannoDateType -> JannoDateType
JannoDateType -> JannoDateType -> [JannoDateType]
JannoDateType -> JannoDateType -> JannoDateType -> [JannoDateType]
(JannoDateType -> JannoDateType)
-> (JannoDateType -> JannoDateType)
-> (Int -> JannoDateType)
-> (JannoDateType -> Int)
-> (JannoDateType -> [JannoDateType])
-> (JannoDateType -> JannoDateType -> [JannoDateType])
-> (JannoDateType -> JannoDateType -> [JannoDateType])
-> (JannoDateType
    -> JannoDateType -> JannoDateType -> [JannoDateType])
-> Enum JannoDateType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: JannoDateType -> JannoDateType
succ :: JannoDateType -> JannoDateType
$cpred :: JannoDateType -> JannoDateType
pred :: JannoDateType -> JannoDateType
$ctoEnum :: Int -> JannoDateType
toEnum :: Int -> JannoDateType
$cfromEnum :: JannoDateType -> Int
fromEnum :: JannoDateType -> Int
$cenumFrom :: JannoDateType -> [JannoDateType]
enumFrom :: JannoDateType -> [JannoDateType]
$cenumFromThen :: JannoDateType -> JannoDateType -> [JannoDateType]
enumFromThen :: JannoDateType -> JannoDateType -> [JannoDateType]
$cenumFromTo :: JannoDateType -> JannoDateType -> [JannoDateType]
enumFromTo :: JannoDateType -> JannoDateType -> [JannoDateType]
$cenumFromThenTo :: JannoDateType -> JannoDateType -> JannoDateType -> [JannoDateType]
enumFromThenTo :: JannoDateType -> JannoDateType -> JannoDateType -> [JannoDateType]
Enum, JannoDateType
JannoDateType -> JannoDateType -> Bounded JannoDateType
forall a. a -> a -> Bounded a
$cminBound :: JannoDateType
minBound :: JannoDateType
$cmaxBound :: JannoDateType
maxBound :: JannoDateType
Bounded)

instance Makeable JannoDateType where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoDateType
make PoseidonVersion
_ Text
x
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"C14"        = JannoDateType -> m JannoDateType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoDateType
C14
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"contextual" = JannoDateType -> m JannoDateType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoDateType
Contextual
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"modern"     = JannoDateType -> m JannoDateType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoDateType
Modern
        | Bool
otherwise         = [Char] -> m JannoDateType
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDateType) -> [Char] -> m JannoDateType
forall a b. (a -> b) -> a -> b
$ [Char]
"Date_Type is set to " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
". " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
                                     [Char]
"That is not in the allowed set [C14, contextual, modern]."
instance Suspicious JannoDateType where inspect :: JannoDateType -> Maybe [[Char]]
inspect JannoDateType
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoDateType where
    show :: JannoDateType -> [Char]
show JannoDateType
C14        = [Char]
"C14"
    show JannoDateType
Contextual = [Char]
"contextual"
    show JannoDateType
Modern     = [Char]
"modern"
instance Csv.ToField JannoDateType where   toField :: JannoDateType -> Field
toField JannoDateType
x = [Char] -> Field
forall a. ToField a => a -> Field
Csv.toField ([Char] -> Field) -> [Char] -> Field
forall a b. (a -> b) -> a -> b
$ JannoDateType -> [Char]
forall a. Show a => a -> [Char]
show JannoDateType
x
instance FromFieldVersioned JannoDateType where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoDateType
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoDateType
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Date_Type"

-- | A datatype for the Date_C14_Labnr .janno column
newtype JannoDateC14Labnr = JannoDateC14Labnr T.Text deriving (JannoDateC14Labnr -> JannoDateC14Labnr -> Bool
(JannoDateC14Labnr -> JannoDateC14Labnr -> Bool)
-> (JannoDateC14Labnr -> JannoDateC14Labnr -> Bool)
-> Eq JannoDateC14Labnr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoDateC14Labnr -> JannoDateC14Labnr -> Bool
== :: JannoDateC14Labnr -> JannoDateC14Labnr -> Bool
$c/= :: JannoDateC14Labnr -> JannoDateC14Labnr -> Bool
/= :: JannoDateC14Labnr -> JannoDateC14Labnr -> Bool
Eq)
$(makeInstances ''JannoDateC14Labnr "Date_C14_Labnr")

-- | A datatype for the Date_C14_Uncal_BP .janno column
newtype JannoDateC14UncalBP = JannoDateC14UncalBP Int deriving (JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool
(JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool)
-> (JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool)
-> Eq JannoDateC14UncalBP
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool
== :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool
$c/= :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool
/= :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool
Eq, Eq JannoDateC14UncalBP
Eq JannoDateC14UncalBP =>
(JannoDateC14UncalBP -> JannoDateC14UncalBP -> Ordering)
-> (JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool)
-> (JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool)
-> (JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool)
-> (JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool)
-> (JannoDateC14UncalBP
    -> JannoDateC14UncalBP -> JannoDateC14UncalBP)
-> (JannoDateC14UncalBP
    -> JannoDateC14UncalBP -> JannoDateC14UncalBP)
-> Ord JannoDateC14UncalBP
JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool
JannoDateC14UncalBP -> JannoDateC14UncalBP -> Ordering
JannoDateC14UncalBP -> JannoDateC14UncalBP -> JannoDateC14UncalBP
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
$ccompare :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> Ordering
compare :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> Ordering
$c< :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool
< :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool
$c<= :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool
<= :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool
$c> :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool
> :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool
$c>= :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool
>= :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> Bool
$cmax :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> JannoDateC14UncalBP
max :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> JannoDateC14UncalBP
$cmin :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> JannoDateC14UncalBP
min :: JannoDateC14UncalBP -> JannoDateC14UncalBP -> JannoDateC14UncalBP
Ord, (forall x. JannoDateC14UncalBP -> Rep JannoDateC14UncalBP x)
-> (forall x. Rep JannoDateC14UncalBP x -> JannoDateC14UncalBP)
-> Generic JannoDateC14UncalBP
forall x. Rep JannoDateC14UncalBP x -> JannoDateC14UncalBP
forall x. JannoDateC14UncalBP -> Rep JannoDateC14UncalBP x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoDateC14UncalBP -> Rep JannoDateC14UncalBP x
from :: forall x. JannoDateC14UncalBP -> Rep JannoDateC14UncalBP x
$cto :: forall x. Rep JannoDateC14UncalBP x -> JannoDateC14UncalBP
to :: forall x. Rep JannoDateC14UncalBP x -> JannoDateC14UncalBP
Generic)

instance Makeable JannoDateC14UncalBP where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoDateC14UncalBP
make PoseidonVersion
_ Text
x =
        case Reader Int
forall a. Integral a => Reader a
T.decimal Text
x of
            Left [Char]
e -> [Char] -> m JannoDateC14UncalBP
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDateC14UncalBP)
-> [Char] -> m JannoDateC14UncalBP
forall a b. (a -> b) -> a -> b
$ [Char]
"Date_C14_Uncal_BP can not be converted to Int because " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
e
            Right (Int
num, Text
"") -> JannoDateC14UncalBP -> m JannoDateC14UncalBP
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (JannoDateC14UncalBP -> m JannoDateC14UncalBP)
-> JannoDateC14UncalBP -> m JannoDateC14UncalBP
forall a b. (a -> b) -> a -> b
$ Int -> JannoDateC14UncalBP
JannoDateC14UncalBP Int
num
            Right (Int
_, Text
rest) -> [Char] -> m JannoDateC14UncalBP
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDateC14UncalBP)
-> [Char] -> m JannoDateC14UncalBP
forall a b. (a -> b) -> a -> b
$ [Char]
"Date_C14_Uncal_BP can not be converted to Int, because of a trailing " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
rest
instance Suspicious JannoDateC14UncalBP where
    inspect :: JannoDateC14UncalBP -> Maybe [[Char]]
inspect (JannoDateC14UncalBP Int
x)
        | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
60000 = [[Char]] -> Maybe [[Char]]
forall a. a -> Maybe a
Just [[Char]
"Date_C14_Uncal_BP is " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
", so >60k years and thus beyond the \
                             \pratical limit of radiocarbon dating."]
        | Bool
otherwise = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoDateC14UncalBP where          show :: JannoDateC14UncalBP -> [Char]
show (JannoDateC14UncalBP Int
x) = Int -> [Char]
forall a. Show a => a -> [Char]
show Int
x
instance Csv.ToField JannoDateC14UncalBP where   toField :: JannoDateC14UncalBP -> Field
toField (JannoDateC14UncalBP Int
x) = Int -> Field
forall a. ToField a => a -> Field
Csv.toField Int
x
instance FromFieldVersioned JannoDateC14UncalBP where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoDateC14UncalBP
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoDateC14UncalBP
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Date_C14_Uncal_BP"

-- | A datatype for the Date_C14_Uncal_BP_Err .janno column
newtype JannoDateC14UncalBPErr = JannoDateC14UncalBPErr Int deriving (JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool
(JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool)
-> (JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool)
-> Eq JannoDateC14UncalBPErr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool
== :: JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool
$c/= :: JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool
/= :: JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool
Eq, Eq JannoDateC14UncalBPErr
Eq JannoDateC14UncalBPErr =>
(JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Ordering)
-> (JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool)
-> (JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool)
-> (JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool)
-> (JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool)
-> (JannoDateC14UncalBPErr
    -> JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr)
-> (JannoDateC14UncalBPErr
    -> JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr)
-> Ord JannoDateC14UncalBPErr
JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool
JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Ordering
JannoDateC14UncalBPErr
-> JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr
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
$ccompare :: JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Ordering
compare :: JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Ordering
$c< :: JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool
< :: JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool
$c<= :: JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool
<= :: JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool
$c> :: JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool
> :: JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool
$c>= :: JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool
>= :: JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr -> Bool
$cmax :: JannoDateC14UncalBPErr
-> JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr
max :: JannoDateC14UncalBPErr
-> JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr
$cmin :: JannoDateC14UncalBPErr
-> JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr
min :: JannoDateC14UncalBPErr
-> JannoDateC14UncalBPErr -> JannoDateC14UncalBPErr
Ord, (forall x. JannoDateC14UncalBPErr -> Rep JannoDateC14UncalBPErr x)
-> (forall x.
    Rep JannoDateC14UncalBPErr x -> JannoDateC14UncalBPErr)
-> Generic JannoDateC14UncalBPErr
forall x. Rep JannoDateC14UncalBPErr x -> JannoDateC14UncalBPErr
forall x. JannoDateC14UncalBPErr -> Rep JannoDateC14UncalBPErr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoDateC14UncalBPErr -> Rep JannoDateC14UncalBPErr x
from :: forall x. JannoDateC14UncalBPErr -> Rep JannoDateC14UncalBPErr x
$cto :: forall x. Rep JannoDateC14UncalBPErr x -> JannoDateC14UncalBPErr
to :: forall x. Rep JannoDateC14UncalBPErr x -> JannoDateC14UncalBPErr
Generic)

instance Makeable JannoDateC14UncalBPErr where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoDateC14UncalBPErr
make PoseidonVersion
_ Text
x =
        case Reader Int
forall a. Integral a => Reader a
T.decimal Text
x of
            Left [Char]
e -> [Char] -> m JannoDateC14UncalBPErr
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDateC14UncalBPErr)
-> [Char] -> m JannoDateC14UncalBPErr
forall a b. (a -> b) -> a -> b
$ [Char]
"Date_C14_Uncal_BP_Err can not be converted to Int because " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
e
            Right (Int
num, Text
"") -> JannoDateC14UncalBPErr -> m JannoDateC14UncalBPErr
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (JannoDateC14UncalBPErr -> m JannoDateC14UncalBPErr)
-> JannoDateC14UncalBPErr -> m JannoDateC14UncalBPErr
forall a b. (a -> b) -> a -> b
$ Int -> JannoDateC14UncalBPErr
JannoDateC14UncalBPErr Int
num
            Right (Int
_, Text
rest) -> [Char] -> m JannoDateC14UncalBPErr
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDateC14UncalBPErr)
-> [Char] -> m JannoDateC14UncalBPErr
forall a b. (a -> b) -> a -> b
$ [Char]
"Date_C14_Uncal_BP_Err can not be converted to Int, because of a trailing " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
rest
instance Suspicious JannoDateC14UncalBPErr where inspect :: JannoDateC14UncalBPErr -> Maybe [[Char]]
inspect JannoDateC14UncalBPErr
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoDateC14UncalBPErr where          show :: JannoDateC14UncalBPErr -> [Char]
show (JannoDateC14UncalBPErr Int
x) = Int -> [Char]
forall a. Show a => a -> [Char]
show Int
x
instance Csv.ToField JannoDateC14UncalBPErr where   toField :: JannoDateC14UncalBPErr -> Field
toField (JannoDateC14UncalBPErr Int
x) = Int -> Field
forall a. ToField a => a -> Field
Csv.toField Int
x
instance FromFieldVersioned JannoDateC14UncalBPErr where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoDateC14UncalBPErr
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoDateC14UncalBPErr
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Date_C14_Uncal_BP_Err"

-- | A datatype for the Date_BC_AD_Start .janno column
newtype JannoDateBCADStart = JannoDateBCADStart Int deriving (JannoDateBCADStart -> JannoDateBCADStart -> Bool
(JannoDateBCADStart -> JannoDateBCADStart -> Bool)
-> (JannoDateBCADStart -> JannoDateBCADStart -> Bool)
-> Eq JannoDateBCADStart
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoDateBCADStart -> JannoDateBCADStart -> Bool
== :: JannoDateBCADStart -> JannoDateBCADStart -> Bool
$c/= :: JannoDateBCADStart -> JannoDateBCADStart -> Bool
/= :: JannoDateBCADStart -> JannoDateBCADStart -> Bool
Eq, Eq JannoDateBCADStart
Eq JannoDateBCADStart =>
(JannoDateBCADStart -> JannoDateBCADStart -> Ordering)
-> (JannoDateBCADStart -> JannoDateBCADStart -> Bool)
-> (JannoDateBCADStart -> JannoDateBCADStart -> Bool)
-> (JannoDateBCADStart -> JannoDateBCADStart -> Bool)
-> (JannoDateBCADStart -> JannoDateBCADStart -> Bool)
-> (JannoDateBCADStart -> JannoDateBCADStart -> JannoDateBCADStart)
-> (JannoDateBCADStart -> JannoDateBCADStart -> JannoDateBCADStart)
-> Ord JannoDateBCADStart
JannoDateBCADStart -> JannoDateBCADStart -> Bool
JannoDateBCADStart -> JannoDateBCADStart -> Ordering
JannoDateBCADStart -> JannoDateBCADStart -> JannoDateBCADStart
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
$ccompare :: JannoDateBCADStart -> JannoDateBCADStart -> Ordering
compare :: JannoDateBCADStart -> JannoDateBCADStart -> Ordering
$c< :: JannoDateBCADStart -> JannoDateBCADStart -> Bool
< :: JannoDateBCADStart -> JannoDateBCADStart -> Bool
$c<= :: JannoDateBCADStart -> JannoDateBCADStart -> Bool
<= :: JannoDateBCADStart -> JannoDateBCADStart -> Bool
$c> :: JannoDateBCADStart -> JannoDateBCADStart -> Bool
> :: JannoDateBCADStart -> JannoDateBCADStart -> Bool
$c>= :: JannoDateBCADStart -> JannoDateBCADStart -> Bool
>= :: JannoDateBCADStart -> JannoDateBCADStart -> Bool
$cmax :: JannoDateBCADStart -> JannoDateBCADStart -> JannoDateBCADStart
max :: JannoDateBCADStart -> JannoDateBCADStart -> JannoDateBCADStart
$cmin :: JannoDateBCADStart -> JannoDateBCADStart -> JannoDateBCADStart
min :: JannoDateBCADStart -> JannoDateBCADStart -> JannoDateBCADStart
Ord, (forall x. JannoDateBCADStart -> Rep JannoDateBCADStart x)
-> (forall x. Rep JannoDateBCADStart x -> JannoDateBCADStart)
-> Generic JannoDateBCADStart
forall x. Rep JannoDateBCADStart x -> JannoDateBCADStart
forall x. JannoDateBCADStart -> Rep JannoDateBCADStart x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoDateBCADStart -> Rep JannoDateBCADStart x
from :: forall x. JannoDateBCADStart -> Rep JannoDateBCADStart x
$cto :: forall x. Rep JannoDateBCADStart x -> JannoDateBCADStart
to :: forall x. Rep JannoDateBCADStart x -> JannoDateBCADStart
Generic)

instance Makeable JannoDateBCADStart where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoDateBCADStart
make PoseidonVersion
_ Text
x =
        let curYear :: Int
curYear = Int
2024 -- the current year
        in case Reader Int -> Reader Int
forall a. Num a => Reader a -> Reader a
T.signed Reader Int
forall a. Integral a => Reader a
T.decimal Text
x of
            Left [Char]
e -> [Char] -> m JannoDateBCADStart
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDateBCADStart) -> [Char] -> m JannoDateBCADStart
forall a b. (a -> b) -> a -> b
$ [Char]
"Date_BC_AD_Start can not be converted to Int because " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
e
            Right (Int
num, Text
"") ->
                if Int
num Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
curYear
                then [Char] -> m JannoDateBCADStart
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDateBCADStart) -> [Char] -> m JannoDateBCADStart
forall a b. (a -> b) -> a -> b
$ [Char]
"Date_BC_AD_Start " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" later than " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
curYear [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
", which is impossible. " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
                   [Char]
"Did you accidentally enter a BP date?"
                else JannoDateBCADStart -> m JannoDateBCADStart
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (JannoDateBCADStart -> m JannoDateBCADStart)
-> JannoDateBCADStart -> m JannoDateBCADStart
forall a b. (a -> b) -> a -> b
$ Int -> JannoDateBCADStart
JannoDateBCADStart Int
num
            Right (Int
_, Text
rest) -> [Char] -> m JannoDateBCADStart
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDateBCADStart) -> [Char] -> m JannoDateBCADStart
forall a b. (a -> b) -> a -> b
$ [Char]
"Date_BC_AD_Start can not be converted to Int, because of a trailing " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
rest
instance Suspicious JannoDateBCADStart where inspect :: JannoDateBCADStart -> Maybe [[Char]]
inspect JannoDateBCADStart
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoDateBCADStart where          show :: JannoDateBCADStart -> [Char]
show (JannoDateBCADStart Int
x) = Int -> [Char]
forall a. Show a => a -> [Char]
show Int
x
instance Csv.ToField JannoDateBCADStart where   toField :: JannoDateBCADStart -> Field
toField (JannoDateBCADStart Int
x) = Int -> Field
forall a. ToField a => a -> Field
Csv.toField Int
x
instance FromFieldVersioned JannoDateBCADStart where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoDateBCADStart
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoDateBCADStart
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Date_BC_AD_Start"

-- | A datatype for the Date_BC_AD_Median .janno column
newtype JannoDateBCADMedian = JannoDateBCADMedian Int deriving (JannoDateBCADMedian -> JannoDateBCADMedian -> Bool
(JannoDateBCADMedian -> JannoDateBCADMedian -> Bool)
-> (JannoDateBCADMedian -> JannoDateBCADMedian -> Bool)
-> Eq JannoDateBCADMedian
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoDateBCADMedian -> JannoDateBCADMedian -> Bool
== :: JannoDateBCADMedian -> JannoDateBCADMedian -> Bool
$c/= :: JannoDateBCADMedian -> JannoDateBCADMedian -> Bool
/= :: JannoDateBCADMedian -> JannoDateBCADMedian -> Bool
Eq, Eq JannoDateBCADMedian
Eq JannoDateBCADMedian =>
(JannoDateBCADMedian -> JannoDateBCADMedian -> Ordering)
-> (JannoDateBCADMedian -> JannoDateBCADMedian -> Bool)
-> (JannoDateBCADMedian -> JannoDateBCADMedian -> Bool)
-> (JannoDateBCADMedian -> JannoDateBCADMedian -> Bool)
-> (JannoDateBCADMedian -> JannoDateBCADMedian -> Bool)
-> (JannoDateBCADMedian
    -> JannoDateBCADMedian -> JannoDateBCADMedian)
-> (JannoDateBCADMedian
    -> JannoDateBCADMedian -> JannoDateBCADMedian)
-> Ord JannoDateBCADMedian
JannoDateBCADMedian -> JannoDateBCADMedian -> Bool
JannoDateBCADMedian -> JannoDateBCADMedian -> Ordering
JannoDateBCADMedian -> JannoDateBCADMedian -> JannoDateBCADMedian
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
$ccompare :: JannoDateBCADMedian -> JannoDateBCADMedian -> Ordering
compare :: JannoDateBCADMedian -> JannoDateBCADMedian -> Ordering
$c< :: JannoDateBCADMedian -> JannoDateBCADMedian -> Bool
< :: JannoDateBCADMedian -> JannoDateBCADMedian -> Bool
$c<= :: JannoDateBCADMedian -> JannoDateBCADMedian -> Bool
<= :: JannoDateBCADMedian -> JannoDateBCADMedian -> Bool
$c> :: JannoDateBCADMedian -> JannoDateBCADMedian -> Bool
> :: JannoDateBCADMedian -> JannoDateBCADMedian -> Bool
$c>= :: JannoDateBCADMedian -> JannoDateBCADMedian -> Bool
>= :: JannoDateBCADMedian -> JannoDateBCADMedian -> Bool
$cmax :: JannoDateBCADMedian -> JannoDateBCADMedian -> JannoDateBCADMedian
max :: JannoDateBCADMedian -> JannoDateBCADMedian -> JannoDateBCADMedian
$cmin :: JannoDateBCADMedian -> JannoDateBCADMedian -> JannoDateBCADMedian
min :: JannoDateBCADMedian -> JannoDateBCADMedian -> JannoDateBCADMedian
Ord, (forall x. JannoDateBCADMedian -> Rep JannoDateBCADMedian x)
-> (forall x. Rep JannoDateBCADMedian x -> JannoDateBCADMedian)
-> Generic JannoDateBCADMedian
forall x. Rep JannoDateBCADMedian x -> JannoDateBCADMedian
forall x. JannoDateBCADMedian -> Rep JannoDateBCADMedian x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoDateBCADMedian -> Rep JannoDateBCADMedian x
from :: forall x. JannoDateBCADMedian -> Rep JannoDateBCADMedian x
$cto :: forall x. Rep JannoDateBCADMedian x -> JannoDateBCADMedian
to :: forall x. Rep JannoDateBCADMedian x -> JannoDateBCADMedian
Generic)

instance Makeable JannoDateBCADMedian where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoDateBCADMedian
make PoseidonVersion
_ Text
x =
        let curYear :: Int
curYear = Int
2024 -- the current year
        in case Reader Int -> Reader Int
forall a. Num a => Reader a -> Reader a
T.signed Reader Int
forall a. Integral a => Reader a
T.decimal Text
x of
            Left [Char]
e -> [Char] -> m JannoDateBCADMedian
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDateBCADMedian)
-> [Char] -> m JannoDateBCADMedian
forall a b. (a -> b) -> a -> b
$ [Char]
"Date_BC_AD_Median can not be converted to Int because " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
e
            Right (Int
num, Text
"") ->
                if Int
num Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
curYear
                then [Char] -> m JannoDateBCADMedian
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDateBCADMedian)
-> [Char] -> m JannoDateBCADMedian
forall a b. (a -> b) -> a -> b
$ [Char]
"Date_BC_AD_Median " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" later than " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
curYear [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
", which is impossible. " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
                   [Char]
"Did you accidentally enter a BP date?"
                else JannoDateBCADMedian -> m JannoDateBCADMedian
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (JannoDateBCADMedian -> m JannoDateBCADMedian)
-> JannoDateBCADMedian -> m JannoDateBCADMedian
forall a b. (a -> b) -> a -> b
$ Int -> JannoDateBCADMedian
JannoDateBCADMedian Int
num
            Right (Int
_, Text
rest) -> [Char] -> m JannoDateBCADMedian
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDateBCADMedian)
-> [Char] -> m JannoDateBCADMedian
forall a b. (a -> b) -> a -> b
$ [Char]
"Date_BC_AD_Median can not be converted to Int, because of a trailing " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
rest
instance Suspicious JannoDateBCADMedian where inspect :: JannoDateBCADMedian -> Maybe [[Char]]
inspect JannoDateBCADMedian
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoDateBCADMedian where          show :: JannoDateBCADMedian -> [Char]
show (JannoDateBCADMedian Int
x) = Int -> [Char]
forall a. Show a => a -> [Char]
show Int
x
instance Csv.ToField JannoDateBCADMedian where   toField :: JannoDateBCADMedian -> Field
toField (JannoDateBCADMedian Int
x) = Int -> Field
forall a. ToField a => a -> Field
Csv.toField Int
x
instance FromFieldVersioned JannoDateBCADMedian where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoDateBCADMedian
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoDateBCADMedian
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Date_BC_AD_Median"

-- | A datatype for the Date_BC_AD_Stop .janno column
newtype JannoDateBCADStop = JannoDateBCADStop Int deriving (JannoDateBCADStop -> JannoDateBCADStop -> Bool
(JannoDateBCADStop -> JannoDateBCADStop -> Bool)
-> (JannoDateBCADStop -> JannoDateBCADStop -> Bool)
-> Eq JannoDateBCADStop
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoDateBCADStop -> JannoDateBCADStop -> Bool
== :: JannoDateBCADStop -> JannoDateBCADStop -> Bool
$c/= :: JannoDateBCADStop -> JannoDateBCADStop -> Bool
/= :: JannoDateBCADStop -> JannoDateBCADStop -> Bool
Eq, Eq JannoDateBCADStop
Eq JannoDateBCADStop =>
(JannoDateBCADStop -> JannoDateBCADStop -> Ordering)
-> (JannoDateBCADStop -> JannoDateBCADStop -> Bool)
-> (JannoDateBCADStop -> JannoDateBCADStop -> Bool)
-> (JannoDateBCADStop -> JannoDateBCADStop -> Bool)
-> (JannoDateBCADStop -> JannoDateBCADStop -> Bool)
-> (JannoDateBCADStop -> JannoDateBCADStop -> JannoDateBCADStop)
-> (JannoDateBCADStop -> JannoDateBCADStop -> JannoDateBCADStop)
-> Ord JannoDateBCADStop
JannoDateBCADStop -> JannoDateBCADStop -> Bool
JannoDateBCADStop -> JannoDateBCADStop -> Ordering
JannoDateBCADStop -> JannoDateBCADStop -> JannoDateBCADStop
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
$ccompare :: JannoDateBCADStop -> JannoDateBCADStop -> Ordering
compare :: JannoDateBCADStop -> JannoDateBCADStop -> Ordering
$c< :: JannoDateBCADStop -> JannoDateBCADStop -> Bool
< :: JannoDateBCADStop -> JannoDateBCADStop -> Bool
$c<= :: JannoDateBCADStop -> JannoDateBCADStop -> Bool
<= :: JannoDateBCADStop -> JannoDateBCADStop -> Bool
$c> :: JannoDateBCADStop -> JannoDateBCADStop -> Bool
> :: JannoDateBCADStop -> JannoDateBCADStop -> Bool
$c>= :: JannoDateBCADStop -> JannoDateBCADStop -> Bool
>= :: JannoDateBCADStop -> JannoDateBCADStop -> Bool
$cmax :: JannoDateBCADStop -> JannoDateBCADStop -> JannoDateBCADStop
max :: JannoDateBCADStop -> JannoDateBCADStop -> JannoDateBCADStop
$cmin :: JannoDateBCADStop -> JannoDateBCADStop -> JannoDateBCADStop
min :: JannoDateBCADStop -> JannoDateBCADStop -> JannoDateBCADStop
Ord, (forall x. JannoDateBCADStop -> Rep JannoDateBCADStop x)
-> (forall x. Rep JannoDateBCADStop x -> JannoDateBCADStop)
-> Generic JannoDateBCADStop
forall x. Rep JannoDateBCADStop x -> JannoDateBCADStop
forall x. JannoDateBCADStop -> Rep JannoDateBCADStop x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoDateBCADStop -> Rep JannoDateBCADStop x
from :: forall x. JannoDateBCADStop -> Rep JannoDateBCADStop x
$cto :: forall x. Rep JannoDateBCADStop x -> JannoDateBCADStop
to :: forall x. Rep JannoDateBCADStop x -> JannoDateBCADStop
Generic)

instance Makeable JannoDateBCADStop where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoDateBCADStop
make PoseidonVersion
_ Text
x =
        let curYear :: Int
curYear = Int
2024 -- the current year
        in case Reader Int -> Reader Int
forall a. Num a => Reader a -> Reader a
T.signed Reader Int
forall a. Integral a => Reader a
T.decimal Text
x of
            Left [Char]
e -> [Char] -> m JannoDateBCADStop
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDateBCADStop) -> [Char] -> m JannoDateBCADStop
forall a b. (a -> b) -> a -> b
$ [Char]
"Date_BC_AD_Stop can not be converted to Int because " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
e
            Right (Int
num, Text
"") ->
                if Int
num Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
curYear
                then [Char] -> m JannoDateBCADStop
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDateBCADStop) -> [Char] -> m JannoDateBCADStop
forall a b. (a -> b) -> a -> b
$ [Char]
"Date_BC_AD_Stop " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" later than " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
curYear [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
", which is impossible. " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
                   [Char]
"Did you accidentally enter a BP date?"
                else JannoDateBCADStop -> m JannoDateBCADStop
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (JannoDateBCADStop -> m JannoDateBCADStop)
-> JannoDateBCADStop -> m JannoDateBCADStop
forall a b. (a -> b) -> a -> b
$ Int -> JannoDateBCADStop
JannoDateBCADStop Int
num
            Right (Int
_, Text
rest) -> [Char] -> m JannoDateBCADStop
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDateBCADStop) -> [Char] -> m JannoDateBCADStop
forall a b. (a -> b) -> a -> b
$ [Char]
"Date_BC_AD_Stop can not be converted to Int, because of a trailing " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
rest
instance Suspicious JannoDateBCADStop where inspect :: JannoDateBCADStop -> Maybe [[Char]]
inspect JannoDateBCADStop
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoDateBCADStop where          show :: JannoDateBCADStop -> [Char]
show (JannoDateBCADStop Int
x) = Int -> [Char]
forall a. Show a => a -> [Char]
show Int
x
instance Csv.ToField JannoDateBCADStop where   toField :: JannoDateBCADStop -> Field
toField (JannoDateBCADStop Int
x) = Int -> Field
forall a. ToField a => a -> Field
Csv.toField Int
x
instance FromFieldVersioned JannoDateBCADStop where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoDateBCADStop
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoDateBCADStop
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Date_BC_AD_Stop"

-- | A datatype for the Chromosomal_Anomalies .janno column
newtype JannoChromosomalAnomalies = JannoChromosomalAnomalies T.Text deriving (JannoChromosomalAnomalies -> JannoChromosomalAnomalies -> Bool
(JannoChromosomalAnomalies -> JannoChromosomalAnomalies -> Bool)
-> (JannoChromosomalAnomalies -> JannoChromosomalAnomalies -> Bool)
-> Eq JannoChromosomalAnomalies
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoChromosomalAnomalies -> JannoChromosomalAnomalies -> Bool
== :: JannoChromosomalAnomalies -> JannoChromosomalAnomalies -> Bool
$c/= :: JannoChromosomalAnomalies -> JannoChromosomalAnomalies -> Bool
/= :: JannoChromosomalAnomalies -> JannoChromosomalAnomalies -> Bool
Eq)
$(makeInstances ''JannoChromosomalAnomalies "Chromosomal_Anomalies")

-- | A datatype for the MT_Haplogroup .janno column
newtype JannoMTHaplogroup = JannoMTHaplogroup T.Text deriving (JannoMTHaplogroup -> JannoMTHaplogroup -> Bool
(JannoMTHaplogroup -> JannoMTHaplogroup -> Bool)
-> (JannoMTHaplogroup -> JannoMTHaplogroup -> Bool)
-> Eq JannoMTHaplogroup
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoMTHaplogroup -> JannoMTHaplogroup -> Bool
== :: JannoMTHaplogroup -> JannoMTHaplogroup -> Bool
$c/= :: JannoMTHaplogroup -> JannoMTHaplogroup -> Bool
/= :: JannoMTHaplogroup -> JannoMTHaplogroup -> Bool
Eq, Eq JannoMTHaplogroup
Eq JannoMTHaplogroup =>
(JannoMTHaplogroup -> JannoMTHaplogroup -> Ordering)
-> (JannoMTHaplogroup -> JannoMTHaplogroup -> Bool)
-> (JannoMTHaplogroup -> JannoMTHaplogroup -> Bool)
-> (JannoMTHaplogroup -> JannoMTHaplogroup -> Bool)
-> (JannoMTHaplogroup -> JannoMTHaplogroup -> Bool)
-> (JannoMTHaplogroup -> JannoMTHaplogroup -> JannoMTHaplogroup)
-> (JannoMTHaplogroup -> JannoMTHaplogroup -> JannoMTHaplogroup)
-> Ord JannoMTHaplogroup
JannoMTHaplogroup -> JannoMTHaplogroup -> Bool
JannoMTHaplogroup -> JannoMTHaplogroup -> Ordering
JannoMTHaplogroup -> JannoMTHaplogroup -> JannoMTHaplogroup
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
$ccompare :: JannoMTHaplogroup -> JannoMTHaplogroup -> Ordering
compare :: JannoMTHaplogroup -> JannoMTHaplogroup -> Ordering
$c< :: JannoMTHaplogroup -> JannoMTHaplogroup -> Bool
< :: JannoMTHaplogroup -> JannoMTHaplogroup -> Bool
$c<= :: JannoMTHaplogroup -> JannoMTHaplogroup -> Bool
<= :: JannoMTHaplogroup -> JannoMTHaplogroup -> Bool
$c> :: JannoMTHaplogroup -> JannoMTHaplogroup -> Bool
> :: JannoMTHaplogroup -> JannoMTHaplogroup -> Bool
$c>= :: JannoMTHaplogroup -> JannoMTHaplogroup -> Bool
>= :: JannoMTHaplogroup -> JannoMTHaplogroup -> Bool
$cmax :: JannoMTHaplogroup -> JannoMTHaplogroup -> JannoMTHaplogroup
max :: JannoMTHaplogroup -> JannoMTHaplogroup -> JannoMTHaplogroup
$cmin :: JannoMTHaplogroup -> JannoMTHaplogroup -> JannoMTHaplogroup
min :: JannoMTHaplogroup -> JannoMTHaplogroup -> JannoMTHaplogroup
Ord)
$(makeInstances ''JannoMTHaplogroup "MT_Haplogroup")

-- | A datatype for the Y_Haplogroup .janno column
newtype JannoYHaplogroup = JannoYHaplogroup T.Text deriving (JannoYHaplogroup -> JannoYHaplogroup -> Bool
(JannoYHaplogroup -> JannoYHaplogroup -> Bool)
-> (JannoYHaplogroup -> JannoYHaplogroup -> Bool)
-> Eq JannoYHaplogroup
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoYHaplogroup -> JannoYHaplogroup -> Bool
== :: JannoYHaplogroup -> JannoYHaplogroup -> Bool
$c/= :: JannoYHaplogroup -> JannoYHaplogroup -> Bool
/= :: JannoYHaplogroup -> JannoYHaplogroup -> Bool
Eq, Eq JannoYHaplogroup
Eq JannoYHaplogroup =>
(JannoYHaplogroup -> JannoYHaplogroup -> Ordering)
-> (JannoYHaplogroup -> JannoYHaplogroup -> Bool)
-> (JannoYHaplogroup -> JannoYHaplogroup -> Bool)
-> (JannoYHaplogroup -> JannoYHaplogroup -> Bool)
-> (JannoYHaplogroup -> JannoYHaplogroup -> Bool)
-> (JannoYHaplogroup -> JannoYHaplogroup -> JannoYHaplogroup)
-> (JannoYHaplogroup -> JannoYHaplogroup -> JannoYHaplogroup)
-> Ord JannoYHaplogroup
JannoYHaplogroup -> JannoYHaplogroup -> Bool
JannoYHaplogroup -> JannoYHaplogroup -> Ordering
JannoYHaplogroup -> JannoYHaplogroup -> JannoYHaplogroup
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
$ccompare :: JannoYHaplogroup -> JannoYHaplogroup -> Ordering
compare :: JannoYHaplogroup -> JannoYHaplogroup -> Ordering
$c< :: JannoYHaplogroup -> JannoYHaplogroup -> Bool
< :: JannoYHaplogroup -> JannoYHaplogroup -> Bool
$c<= :: JannoYHaplogroup -> JannoYHaplogroup -> Bool
<= :: JannoYHaplogroup -> JannoYHaplogroup -> Bool
$c> :: JannoYHaplogroup -> JannoYHaplogroup -> Bool
> :: JannoYHaplogroup -> JannoYHaplogroup -> Bool
$c>= :: JannoYHaplogroup -> JannoYHaplogroup -> Bool
>= :: JannoYHaplogroup -> JannoYHaplogroup -> Bool
$cmax :: JannoYHaplogroup -> JannoYHaplogroup -> JannoYHaplogroup
max :: JannoYHaplogroup -> JannoYHaplogroup -> JannoYHaplogroup
$cmin :: JannoYHaplogroup -> JannoYHaplogroup -> JannoYHaplogroup
min :: JannoYHaplogroup -> JannoYHaplogroup -> JannoYHaplogroup
Ord)
$(makeInstances ''JannoYHaplogroup "Y_Haplogroup")

-- | A datatype for the Source_Material .janno column
data JannoSourceMaterial =
      MaterialPetrous
    | MaterialBone
    | MaterialTooth
    | MaterialHair
    | MaterialSoft
    | MaterialSediment
    | MaterialOther
    deriving (JannoSourceMaterial -> JannoSourceMaterial -> Bool
(JannoSourceMaterial -> JannoSourceMaterial -> Bool)
-> (JannoSourceMaterial -> JannoSourceMaterial -> Bool)
-> Eq JannoSourceMaterial
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoSourceMaterial -> JannoSourceMaterial -> Bool
== :: JannoSourceMaterial -> JannoSourceMaterial -> Bool
$c/= :: JannoSourceMaterial -> JannoSourceMaterial -> Bool
/= :: JannoSourceMaterial -> JannoSourceMaterial -> Bool
Eq, Eq JannoSourceMaterial
Eq JannoSourceMaterial =>
(JannoSourceMaterial -> JannoSourceMaterial -> Ordering)
-> (JannoSourceMaterial -> JannoSourceMaterial -> Bool)
-> (JannoSourceMaterial -> JannoSourceMaterial -> Bool)
-> (JannoSourceMaterial -> JannoSourceMaterial -> Bool)
-> (JannoSourceMaterial -> JannoSourceMaterial -> Bool)
-> (JannoSourceMaterial
    -> JannoSourceMaterial -> JannoSourceMaterial)
-> (JannoSourceMaterial
    -> JannoSourceMaterial -> JannoSourceMaterial)
-> Ord JannoSourceMaterial
JannoSourceMaterial -> JannoSourceMaterial -> Bool
JannoSourceMaterial -> JannoSourceMaterial -> Ordering
JannoSourceMaterial -> JannoSourceMaterial -> JannoSourceMaterial
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
$ccompare :: JannoSourceMaterial -> JannoSourceMaterial -> Ordering
compare :: JannoSourceMaterial -> JannoSourceMaterial -> Ordering
$c< :: JannoSourceMaterial -> JannoSourceMaterial -> Bool
< :: JannoSourceMaterial -> JannoSourceMaterial -> Bool
$c<= :: JannoSourceMaterial -> JannoSourceMaterial -> Bool
<= :: JannoSourceMaterial -> JannoSourceMaterial -> Bool
$c> :: JannoSourceMaterial -> JannoSourceMaterial -> Bool
> :: JannoSourceMaterial -> JannoSourceMaterial -> Bool
$c>= :: JannoSourceMaterial -> JannoSourceMaterial -> Bool
>= :: JannoSourceMaterial -> JannoSourceMaterial -> Bool
$cmax :: JannoSourceMaterial -> JannoSourceMaterial -> JannoSourceMaterial
max :: JannoSourceMaterial -> JannoSourceMaterial -> JannoSourceMaterial
$cmin :: JannoSourceMaterial -> JannoSourceMaterial -> JannoSourceMaterial
min :: JannoSourceMaterial -> JannoSourceMaterial -> JannoSourceMaterial
Ord, (forall x. JannoSourceMaterial -> Rep JannoSourceMaterial x)
-> (forall x. Rep JannoSourceMaterial x -> JannoSourceMaterial)
-> Generic JannoSourceMaterial
forall x. Rep JannoSourceMaterial x -> JannoSourceMaterial
forall x. JannoSourceMaterial -> Rep JannoSourceMaterial x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoSourceMaterial -> Rep JannoSourceMaterial x
from :: forall x. JannoSourceMaterial -> Rep JannoSourceMaterial x
$cto :: forall x. Rep JannoSourceMaterial x -> JannoSourceMaterial
to :: forall x. Rep JannoSourceMaterial x -> JannoSourceMaterial
Generic, Int -> JannoSourceMaterial
JannoSourceMaterial -> Int
JannoSourceMaterial -> [JannoSourceMaterial]
JannoSourceMaterial -> JannoSourceMaterial
JannoSourceMaterial -> JannoSourceMaterial -> [JannoSourceMaterial]
JannoSourceMaterial
-> JannoSourceMaterial
-> JannoSourceMaterial
-> [JannoSourceMaterial]
(JannoSourceMaterial -> JannoSourceMaterial)
-> (JannoSourceMaterial -> JannoSourceMaterial)
-> (Int -> JannoSourceMaterial)
-> (JannoSourceMaterial -> Int)
-> (JannoSourceMaterial -> [JannoSourceMaterial])
-> (JannoSourceMaterial
    -> JannoSourceMaterial -> [JannoSourceMaterial])
-> (JannoSourceMaterial
    -> JannoSourceMaterial -> [JannoSourceMaterial])
-> (JannoSourceMaterial
    -> JannoSourceMaterial
    -> JannoSourceMaterial
    -> [JannoSourceMaterial])
-> Enum JannoSourceMaterial
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: JannoSourceMaterial -> JannoSourceMaterial
succ :: JannoSourceMaterial -> JannoSourceMaterial
$cpred :: JannoSourceMaterial -> JannoSourceMaterial
pred :: JannoSourceMaterial -> JannoSourceMaterial
$ctoEnum :: Int -> JannoSourceMaterial
toEnum :: Int -> JannoSourceMaterial
$cfromEnum :: JannoSourceMaterial -> Int
fromEnum :: JannoSourceMaterial -> Int
$cenumFrom :: JannoSourceMaterial -> [JannoSourceMaterial]
enumFrom :: JannoSourceMaterial -> [JannoSourceMaterial]
$cenumFromThen :: JannoSourceMaterial -> JannoSourceMaterial -> [JannoSourceMaterial]
enumFromThen :: JannoSourceMaterial -> JannoSourceMaterial -> [JannoSourceMaterial]
$cenumFromTo :: JannoSourceMaterial -> JannoSourceMaterial -> [JannoSourceMaterial]
enumFromTo :: JannoSourceMaterial -> JannoSourceMaterial -> [JannoSourceMaterial]
$cenumFromThenTo :: JannoSourceMaterial
-> JannoSourceMaterial
-> JannoSourceMaterial
-> [JannoSourceMaterial]
enumFromThenTo :: JannoSourceMaterial
-> JannoSourceMaterial
-> JannoSourceMaterial
-> [JannoSourceMaterial]
Enum, JannoSourceMaterial
JannoSourceMaterial
-> JannoSourceMaterial -> Bounded JannoSourceMaterial
forall a. a -> a -> Bounded a
$cminBound :: JannoSourceMaterial
minBound :: JannoSourceMaterial
$cmaxBound :: JannoSourceMaterial
maxBound :: JannoSourceMaterial
Bounded)

instance Makeable JannoSourceMaterial where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoSourceMaterial
make PoseidonVersion
_ Text
x
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"petrous"  = JannoSourceMaterial -> m JannoSourceMaterial
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoSourceMaterial
MaterialPetrous
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"bone"     = JannoSourceMaterial -> m JannoSourceMaterial
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoSourceMaterial
MaterialBone
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"tooth"    = JannoSourceMaterial -> m JannoSourceMaterial
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoSourceMaterial
MaterialTooth
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"hair"     = JannoSourceMaterial -> m JannoSourceMaterial
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoSourceMaterial
MaterialHair
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"soft"     = JannoSourceMaterial -> m JannoSourceMaterial
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoSourceMaterial
MaterialSoft
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"sediment" = JannoSourceMaterial -> m JannoSourceMaterial
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoSourceMaterial
MaterialSediment
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"other"    = JannoSourceMaterial -> m JannoSourceMaterial
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoSourceMaterial
MaterialOther
        | Bool
otherwise       = [Char] -> m JannoSourceMaterial
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoSourceMaterial)
-> [Char] -> m JannoSourceMaterial
forall a b. (a -> b) -> a -> b
$ [Char]
"Source_Material is set to " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
". " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
                                   [Char]
"That is not in the allowed set [petrous, bone, tooth, hair, \
                                   \soft, sediment, other]."
instance Suspicious JannoSourceMaterial where inspect :: JannoSourceMaterial -> Maybe [[Char]]
inspect JannoSourceMaterial
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoSourceMaterial where
    show :: JannoSourceMaterial -> [Char]
show JannoSourceMaterial
MaterialPetrous  = [Char]
"petrous"
    show JannoSourceMaterial
MaterialBone     = [Char]
"bone"
    show JannoSourceMaterial
MaterialTooth    = [Char]
"tooth"
    show JannoSourceMaterial
MaterialHair     = [Char]
"hair"
    show JannoSourceMaterial
MaterialSoft     = [Char]
"soft"
    show JannoSourceMaterial
MaterialSediment = [Char]
"sediment"
    show JannoSourceMaterial
MaterialOther    = [Char]
"other"
instance Csv.ToField JannoSourceMaterial where   toField :: JannoSourceMaterial -> Field
toField JannoSourceMaterial
x = [Char] -> Field
forall a. ToField a => a -> Field
Csv.toField ([Char] -> Field) -> [Char] -> Field
forall a b. (a -> b) -> a -> b
$ JannoSourceMaterial -> [Char]
forall a. Show a => a -> [Char]
show JannoSourceMaterial
x
instance FromFieldVersioned JannoSourceMaterial where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoSourceMaterial
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoSourceMaterial
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Source_Material"

-- | A datatype for the Nr_Libraries .janno column
newtype JannoNrLibraries = JannoNrLibraries Int deriving (JannoNrLibraries -> JannoNrLibraries -> Bool
(JannoNrLibraries -> JannoNrLibraries -> Bool)
-> (JannoNrLibraries -> JannoNrLibraries -> Bool)
-> Eq JannoNrLibraries
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoNrLibraries -> JannoNrLibraries -> Bool
== :: JannoNrLibraries -> JannoNrLibraries -> Bool
$c/= :: JannoNrLibraries -> JannoNrLibraries -> Bool
/= :: JannoNrLibraries -> JannoNrLibraries -> Bool
Eq, Eq JannoNrLibraries
Eq JannoNrLibraries =>
(JannoNrLibraries -> JannoNrLibraries -> Ordering)
-> (JannoNrLibraries -> JannoNrLibraries -> Bool)
-> (JannoNrLibraries -> JannoNrLibraries -> Bool)
-> (JannoNrLibraries -> JannoNrLibraries -> Bool)
-> (JannoNrLibraries -> JannoNrLibraries -> Bool)
-> (JannoNrLibraries -> JannoNrLibraries -> JannoNrLibraries)
-> (JannoNrLibraries -> JannoNrLibraries -> JannoNrLibraries)
-> Ord JannoNrLibraries
JannoNrLibraries -> JannoNrLibraries -> Bool
JannoNrLibraries -> JannoNrLibraries -> Ordering
JannoNrLibraries -> JannoNrLibraries -> JannoNrLibraries
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
$ccompare :: JannoNrLibraries -> JannoNrLibraries -> Ordering
compare :: JannoNrLibraries -> JannoNrLibraries -> Ordering
$c< :: JannoNrLibraries -> JannoNrLibraries -> Bool
< :: JannoNrLibraries -> JannoNrLibraries -> Bool
$c<= :: JannoNrLibraries -> JannoNrLibraries -> Bool
<= :: JannoNrLibraries -> JannoNrLibraries -> Bool
$c> :: JannoNrLibraries -> JannoNrLibraries -> Bool
> :: JannoNrLibraries -> JannoNrLibraries -> Bool
$c>= :: JannoNrLibraries -> JannoNrLibraries -> Bool
>= :: JannoNrLibraries -> JannoNrLibraries -> Bool
$cmax :: JannoNrLibraries -> JannoNrLibraries -> JannoNrLibraries
max :: JannoNrLibraries -> JannoNrLibraries -> JannoNrLibraries
$cmin :: JannoNrLibraries -> JannoNrLibraries -> JannoNrLibraries
min :: JannoNrLibraries -> JannoNrLibraries -> JannoNrLibraries
Ord, (forall x. JannoNrLibraries -> Rep JannoNrLibraries x)
-> (forall x. Rep JannoNrLibraries x -> JannoNrLibraries)
-> Generic JannoNrLibraries
forall x. Rep JannoNrLibraries x -> JannoNrLibraries
forall x. JannoNrLibraries -> Rep JannoNrLibraries x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoNrLibraries -> Rep JannoNrLibraries x
from :: forall x. JannoNrLibraries -> Rep JannoNrLibraries x
$cto :: forall x. Rep JannoNrLibraries x -> JannoNrLibraries
to :: forall x. Rep JannoNrLibraries x -> JannoNrLibraries
Generic)

instance Makeable JannoNrLibraries where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoNrLibraries
make PoseidonVersion
_ Text
x =
        case Reader Int -> Reader Int
forall a. Num a => Reader a -> Reader a
T.signed Reader Int
forall a. Integral a => Reader a
T.decimal Text
x of
            Left [Char]
e -> [Char] -> m JannoNrLibraries
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoNrLibraries) -> [Char] -> m JannoNrLibraries
forall a b. (a -> b) -> a -> b
$ [Char]
"Nr_Libraries can not be converted to Int because " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
e
            Right (Int
num, Text
"") ->
                if Int
num Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
1
                then [Char] -> m JannoNrLibraries
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoNrLibraries) -> [Char] -> m JannoNrLibraries
forall a b. (a -> b) -> a -> b
$ [Char]
"Nr_Libraries " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" lower than 1, which is impossible."
                else JannoNrLibraries -> m JannoNrLibraries
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (JannoNrLibraries -> m JannoNrLibraries)
-> JannoNrLibraries -> m JannoNrLibraries
forall a b. (a -> b) -> a -> b
$ Int -> JannoNrLibraries
JannoNrLibraries Int
num
            Right (Int
_, Text
rest) -> [Char] -> m JannoNrLibraries
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoNrLibraries) -> [Char] -> m JannoNrLibraries
forall a b. (a -> b) -> a -> b
$ [Char]
"Nr_Libraries can not be converted to Int, because of a trailing " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
rest
instance Suspicious JannoNrLibraries where inspect :: JannoNrLibraries -> Maybe [[Char]]
inspect JannoNrLibraries
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoNrLibraries where          show :: JannoNrLibraries -> [Char]
show (JannoNrLibraries Int
x) = Int -> [Char]
forall a. Show a => a -> [Char]
show Int
x
instance Csv.ToField JannoNrLibraries where   toField :: JannoNrLibraries -> Field
toField (JannoNrLibraries Int
x) = Int -> Field
forall a. ToField a => a -> Field
Csv.toField Int
x
instance FromFieldVersioned JannoNrLibraries where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoNrLibraries
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoNrLibraries
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Nr_Libraries"

-- | A datatype for the Library_Names .janno column
newtype JannoLibraryName = JannoLibraryName T.Text deriving (JannoLibraryName -> JannoLibraryName -> Bool
(JannoLibraryName -> JannoLibraryName -> Bool)
-> (JannoLibraryName -> JannoLibraryName -> Bool)
-> Eq JannoLibraryName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoLibraryName -> JannoLibraryName -> Bool
== :: JannoLibraryName -> JannoLibraryName -> Bool
$c/= :: JannoLibraryName -> JannoLibraryName -> Bool
/= :: JannoLibraryName -> JannoLibraryName -> Bool
Eq)
$(makeInstances ''JannoLibraryName "Library_Names")

-- | A datatype for the Capture_Type .janno column
data JannoCaptureType =
      Shotgun
    | A1240K
    | ArborComplete
    | ArborPrimePlus
    | ArborAncestralPlus
    | TwistAncientDNA
    | WISC2013
    | OtherCapture
    | LegacyReferenceGenome -- was removed in Poseidon v3.0.0, kept here for compatibility
    deriving (JannoCaptureType -> JannoCaptureType -> Bool
(JannoCaptureType -> JannoCaptureType -> Bool)
-> (JannoCaptureType -> JannoCaptureType -> Bool)
-> Eq JannoCaptureType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoCaptureType -> JannoCaptureType -> Bool
== :: JannoCaptureType -> JannoCaptureType -> Bool
$c/= :: JannoCaptureType -> JannoCaptureType -> Bool
/= :: JannoCaptureType -> JannoCaptureType -> Bool
Eq, Eq JannoCaptureType
Eq JannoCaptureType =>
(JannoCaptureType -> JannoCaptureType -> Ordering)
-> (JannoCaptureType -> JannoCaptureType -> Bool)
-> (JannoCaptureType -> JannoCaptureType -> Bool)
-> (JannoCaptureType -> JannoCaptureType -> Bool)
-> (JannoCaptureType -> JannoCaptureType -> Bool)
-> (JannoCaptureType -> JannoCaptureType -> JannoCaptureType)
-> (JannoCaptureType -> JannoCaptureType -> JannoCaptureType)
-> Ord JannoCaptureType
JannoCaptureType -> JannoCaptureType -> Bool
JannoCaptureType -> JannoCaptureType -> Ordering
JannoCaptureType -> JannoCaptureType -> JannoCaptureType
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
$ccompare :: JannoCaptureType -> JannoCaptureType -> Ordering
compare :: JannoCaptureType -> JannoCaptureType -> Ordering
$c< :: JannoCaptureType -> JannoCaptureType -> Bool
< :: JannoCaptureType -> JannoCaptureType -> Bool
$c<= :: JannoCaptureType -> JannoCaptureType -> Bool
<= :: JannoCaptureType -> JannoCaptureType -> Bool
$c> :: JannoCaptureType -> JannoCaptureType -> Bool
> :: JannoCaptureType -> JannoCaptureType -> Bool
$c>= :: JannoCaptureType -> JannoCaptureType -> Bool
>= :: JannoCaptureType -> JannoCaptureType -> Bool
$cmax :: JannoCaptureType -> JannoCaptureType -> JannoCaptureType
max :: JannoCaptureType -> JannoCaptureType -> JannoCaptureType
$cmin :: JannoCaptureType -> JannoCaptureType -> JannoCaptureType
min :: JannoCaptureType -> JannoCaptureType -> JannoCaptureType
Ord, (forall x. JannoCaptureType -> Rep JannoCaptureType x)
-> (forall x. Rep JannoCaptureType x -> JannoCaptureType)
-> Generic JannoCaptureType
forall x. Rep JannoCaptureType x -> JannoCaptureType
forall x. JannoCaptureType -> Rep JannoCaptureType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoCaptureType -> Rep JannoCaptureType x
from :: forall x. JannoCaptureType -> Rep JannoCaptureType x
$cto :: forall x. Rep JannoCaptureType x -> JannoCaptureType
to :: forall x. Rep JannoCaptureType x -> JannoCaptureType
Generic, Int -> JannoCaptureType
JannoCaptureType -> Int
JannoCaptureType -> [JannoCaptureType]
JannoCaptureType -> JannoCaptureType
JannoCaptureType -> JannoCaptureType -> [JannoCaptureType]
JannoCaptureType
-> JannoCaptureType -> JannoCaptureType -> [JannoCaptureType]
(JannoCaptureType -> JannoCaptureType)
-> (JannoCaptureType -> JannoCaptureType)
-> (Int -> JannoCaptureType)
-> (JannoCaptureType -> Int)
-> (JannoCaptureType -> [JannoCaptureType])
-> (JannoCaptureType -> JannoCaptureType -> [JannoCaptureType])
-> (JannoCaptureType -> JannoCaptureType -> [JannoCaptureType])
-> (JannoCaptureType
    -> JannoCaptureType -> JannoCaptureType -> [JannoCaptureType])
-> Enum JannoCaptureType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: JannoCaptureType -> JannoCaptureType
succ :: JannoCaptureType -> JannoCaptureType
$cpred :: JannoCaptureType -> JannoCaptureType
pred :: JannoCaptureType -> JannoCaptureType
$ctoEnum :: Int -> JannoCaptureType
toEnum :: Int -> JannoCaptureType
$cfromEnum :: JannoCaptureType -> Int
fromEnum :: JannoCaptureType -> Int
$cenumFrom :: JannoCaptureType -> [JannoCaptureType]
enumFrom :: JannoCaptureType -> [JannoCaptureType]
$cenumFromThen :: JannoCaptureType -> JannoCaptureType -> [JannoCaptureType]
enumFromThen :: JannoCaptureType -> JannoCaptureType -> [JannoCaptureType]
$cenumFromTo :: JannoCaptureType -> JannoCaptureType -> [JannoCaptureType]
enumFromTo :: JannoCaptureType -> JannoCaptureType -> [JannoCaptureType]
$cenumFromThenTo :: JannoCaptureType
-> JannoCaptureType -> JannoCaptureType -> [JannoCaptureType]
enumFromThenTo :: JannoCaptureType
-> JannoCaptureType -> JannoCaptureType -> [JannoCaptureType]
Enum, JannoCaptureType
JannoCaptureType -> JannoCaptureType -> Bounded JannoCaptureType
forall a. a -> a -> Bounded a
$cminBound :: JannoCaptureType
minBound :: JannoCaptureType
$cmaxBound :: JannoCaptureType
maxBound :: JannoCaptureType
Bounded)

instance Makeable JannoCaptureType where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoCaptureType
make PoseidonVersion
pv Text
x
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"Shotgun"            = JannoCaptureType -> m JannoCaptureType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoCaptureType
Shotgun
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"1240K"              = JannoCaptureType -> m JannoCaptureType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoCaptureType
A1240K
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"ArborComplete"      = JannoCaptureType -> m JannoCaptureType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoCaptureType
ArborComplete
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"ArborPrimePlus"     = JannoCaptureType -> m JannoCaptureType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoCaptureType
ArborPrimePlus
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"ArborAncestralPlus" = JannoCaptureType -> m JannoCaptureType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoCaptureType
ArborAncestralPlus
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"TwistAncientDNA"    = JannoCaptureType -> m JannoCaptureType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoCaptureType
TwistAncientDNA
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"WISC2013"           = JannoCaptureType -> m JannoCaptureType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoCaptureType
WISC2013
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"OtherCapture"       = JannoCaptureType -> m JannoCaptureType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoCaptureType
OtherCapture
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"ReferenceGenome" Bool -> Bool -> Bool
&& PoseidonVersion -> Version
asVersion PoseidonVersion
pv Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
< [Int] -> Version
makeVersion [Int
3,Int
0,Int
0] = JannoCaptureType -> m JannoCaptureType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoCaptureType
LegacyReferenceGenome
        | Bool
otherwise = [Char] -> m JannoCaptureType
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoCaptureType) -> [Char] -> m JannoCaptureType
forall a b. (a -> b) -> a -> b
$ [Char]
"Capture_Type is set to " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
". " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
                        [Char]
"That is not in the allowed set [Shotgun, 1240K, ArborComplete, \
                        \ArborPrimePlus, ArborAncestralPlus, TwistAncientDNA, WISC2013, \
                        \OtherCapture]. Note that ReferenceGenome was retired in Poseidon v3.0.0."

instance Suspicious JannoCaptureType where inspect :: JannoCaptureType -> Maybe [[Char]]
inspect JannoCaptureType
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoCaptureType where
    show :: JannoCaptureType -> [Char]
show JannoCaptureType
Shotgun               = [Char]
"Shotgun"
    show JannoCaptureType
A1240K                = [Char]
"1240K"
    show JannoCaptureType
ArborComplete         = [Char]
"ArborComplete"
    show JannoCaptureType
ArborPrimePlus        = [Char]
"ArborPrimePlus"
    show JannoCaptureType
ArborAncestralPlus    = [Char]
"ArborAncestralPlus"
    show JannoCaptureType
TwistAncientDNA       = [Char]
"TwistAncientDNA"
    show JannoCaptureType
WISC2013              = [Char]
"WISC2013"
    show JannoCaptureType
OtherCapture          = [Char]
"OtherCapture"
    show JannoCaptureType
LegacyReferenceGenome = [Char]
"ReferenceGenome"
instance Csv.ToField JannoCaptureType where   toField :: JannoCaptureType -> Field
toField JannoCaptureType
x = [Char] -> Field
forall a. ToField a => a -> Field
Csv.toField ([Char] -> Field) -> [Char] -> Field
forall a b. (a -> b) -> a -> b
$ JannoCaptureType -> [Char]
forall a. Show a => a -> [Char]
show JannoCaptureType
x
instance FromFieldVersioned JannoCaptureType where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoCaptureType
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoCaptureType
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Capture_Type"

-- | A datatype for the UDG .janno column
data JannoUDG =
      Minus
    | Half
    | Plus
    | Mixed
    deriving (JannoUDG -> JannoUDG -> Bool
(JannoUDG -> JannoUDG -> Bool)
-> (JannoUDG -> JannoUDG -> Bool) -> Eq JannoUDG
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoUDG -> JannoUDG -> Bool
== :: JannoUDG -> JannoUDG -> Bool
$c/= :: JannoUDG -> JannoUDG -> Bool
/= :: JannoUDG -> JannoUDG -> Bool
Eq, Eq JannoUDG
Eq JannoUDG =>
(JannoUDG -> JannoUDG -> Ordering)
-> (JannoUDG -> JannoUDG -> Bool)
-> (JannoUDG -> JannoUDG -> Bool)
-> (JannoUDG -> JannoUDG -> Bool)
-> (JannoUDG -> JannoUDG -> Bool)
-> (JannoUDG -> JannoUDG -> JannoUDG)
-> (JannoUDG -> JannoUDG -> JannoUDG)
-> Ord JannoUDG
JannoUDG -> JannoUDG -> Bool
JannoUDG -> JannoUDG -> Ordering
JannoUDG -> JannoUDG -> JannoUDG
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
$ccompare :: JannoUDG -> JannoUDG -> Ordering
compare :: JannoUDG -> JannoUDG -> Ordering
$c< :: JannoUDG -> JannoUDG -> Bool
< :: JannoUDG -> JannoUDG -> Bool
$c<= :: JannoUDG -> JannoUDG -> Bool
<= :: JannoUDG -> JannoUDG -> Bool
$c> :: JannoUDG -> JannoUDG -> Bool
> :: JannoUDG -> JannoUDG -> Bool
$c>= :: JannoUDG -> JannoUDG -> Bool
>= :: JannoUDG -> JannoUDG -> Bool
$cmax :: JannoUDG -> JannoUDG -> JannoUDG
max :: JannoUDG -> JannoUDG -> JannoUDG
$cmin :: JannoUDG -> JannoUDG -> JannoUDG
min :: JannoUDG -> JannoUDG -> JannoUDG
Ord, (forall x. JannoUDG -> Rep JannoUDG x)
-> (forall x. Rep JannoUDG x -> JannoUDG) -> Generic JannoUDG
forall x. Rep JannoUDG x -> JannoUDG
forall x. JannoUDG -> Rep JannoUDG x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoUDG -> Rep JannoUDG x
from :: forall x. JannoUDG -> Rep JannoUDG x
$cto :: forall x. Rep JannoUDG x -> JannoUDG
to :: forall x. Rep JannoUDG x -> JannoUDG
Generic, Int -> JannoUDG
JannoUDG -> Int
JannoUDG -> [JannoUDG]
JannoUDG -> JannoUDG
JannoUDG -> JannoUDG -> [JannoUDG]
JannoUDG -> JannoUDG -> JannoUDG -> [JannoUDG]
(JannoUDG -> JannoUDG)
-> (JannoUDG -> JannoUDG)
-> (Int -> JannoUDG)
-> (JannoUDG -> Int)
-> (JannoUDG -> [JannoUDG])
-> (JannoUDG -> JannoUDG -> [JannoUDG])
-> (JannoUDG -> JannoUDG -> [JannoUDG])
-> (JannoUDG -> JannoUDG -> JannoUDG -> [JannoUDG])
-> Enum JannoUDG
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: JannoUDG -> JannoUDG
succ :: JannoUDG -> JannoUDG
$cpred :: JannoUDG -> JannoUDG
pred :: JannoUDG -> JannoUDG
$ctoEnum :: Int -> JannoUDG
toEnum :: Int -> JannoUDG
$cfromEnum :: JannoUDG -> Int
fromEnum :: JannoUDG -> Int
$cenumFrom :: JannoUDG -> [JannoUDG]
enumFrom :: JannoUDG -> [JannoUDG]
$cenumFromThen :: JannoUDG -> JannoUDG -> [JannoUDG]
enumFromThen :: JannoUDG -> JannoUDG -> [JannoUDG]
$cenumFromTo :: JannoUDG -> JannoUDG -> [JannoUDG]
enumFromTo :: JannoUDG -> JannoUDG -> [JannoUDG]
$cenumFromThenTo :: JannoUDG -> JannoUDG -> JannoUDG -> [JannoUDG]
enumFromThenTo :: JannoUDG -> JannoUDG -> JannoUDG -> [JannoUDG]
Enum, JannoUDG
JannoUDG -> JannoUDG -> Bounded JannoUDG
forall a. a -> a -> Bounded a
$cminBound :: JannoUDG
minBound :: JannoUDG
$cmaxBound :: JannoUDG
maxBound :: JannoUDG
Bounded)

instance Makeable JannoUDG where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoUDG
make PoseidonVersion
_ Text
x
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"minus" = JannoUDG -> m JannoUDG
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoUDG
Minus
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"half"  = JannoUDG -> m JannoUDG
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoUDG
Half
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"plus"  = JannoUDG -> m JannoUDG
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoUDG
Plus
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"mixed" = JannoUDG -> m JannoUDG
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoUDG
Mixed
        | Bool
otherwise    = [Char] -> m JannoUDG
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoUDG) -> [Char] -> m JannoUDG
forall a b. (a -> b) -> a -> b
$ [Char]
"UDG is set to " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
". " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
                                [Char]
"That is not in the allowed set [minus, half, plus, mixed]."
instance Suspicious JannoUDG where inspect :: JannoUDG -> Maybe [[Char]]
inspect JannoUDG
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoUDG where
    show :: JannoUDG -> [Char]
show JannoUDG
Minus = [Char]
"minus"
    show JannoUDG
Half  = [Char]
"half"
    show JannoUDG
Plus  = [Char]
"plus"
    show JannoUDG
Mixed = [Char]
"mixed"
instance Csv.ToField JannoUDG where   toField :: JannoUDG -> Field
toField JannoUDG
x = [Char] -> Field
forall a. ToField a => a -> Field
Csv.toField ([Char] -> Field) -> [Char] -> Field
forall a b. (a -> b) -> a -> b
$ JannoUDG -> [Char]
forall a. Show a => a -> [Char]
show JannoUDG
x
instance FromFieldVersioned JannoUDG where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoUDG
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoUDG
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"UDG"

-- | A datatype for the Library_Built .janno column
data JannoLibraryBuilt =
      DS
    | SS
    | MixedSSDS
    | Other -- the "other" option is deprecated and should be removed at some point
    deriving (JannoLibraryBuilt -> JannoLibraryBuilt -> Bool
(JannoLibraryBuilt -> JannoLibraryBuilt -> Bool)
-> (JannoLibraryBuilt -> JannoLibraryBuilt -> Bool)
-> Eq JannoLibraryBuilt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoLibraryBuilt -> JannoLibraryBuilt -> Bool
== :: JannoLibraryBuilt -> JannoLibraryBuilt -> Bool
$c/= :: JannoLibraryBuilt -> JannoLibraryBuilt -> Bool
/= :: JannoLibraryBuilt -> JannoLibraryBuilt -> Bool
Eq, Eq JannoLibraryBuilt
Eq JannoLibraryBuilt =>
(JannoLibraryBuilt -> JannoLibraryBuilt -> Ordering)
-> (JannoLibraryBuilt -> JannoLibraryBuilt -> Bool)
-> (JannoLibraryBuilt -> JannoLibraryBuilt -> Bool)
-> (JannoLibraryBuilt -> JannoLibraryBuilt -> Bool)
-> (JannoLibraryBuilt -> JannoLibraryBuilt -> Bool)
-> (JannoLibraryBuilt -> JannoLibraryBuilt -> JannoLibraryBuilt)
-> (JannoLibraryBuilt -> JannoLibraryBuilt -> JannoLibraryBuilt)
-> Ord JannoLibraryBuilt
JannoLibraryBuilt -> JannoLibraryBuilt -> Bool
JannoLibraryBuilt -> JannoLibraryBuilt -> Ordering
JannoLibraryBuilt -> JannoLibraryBuilt -> JannoLibraryBuilt
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
$ccompare :: JannoLibraryBuilt -> JannoLibraryBuilt -> Ordering
compare :: JannoLibraryBuilt -> JannoLibraryBuilt -> Ordering
$c< :: JannoLibraryBuilt -> JannoLibraryBuilt -> Bool
< :: JannoLibraryBuilt -> JannoLibraryBuilt -> Bool
$c<= :: JannoLibraryBuilt -> JannoLibraryBuilt -> Bool
<= :: JannoLibraryBuilt -> JannoLibraryBuilt -> Bool
$c> :: JannoLibraryBuilt -> JannoLibraryBuilt -> Bool
> :: JannoLibraryBuilt -> JannoLibraryBuilt -> Bool
$c>= :: JannoLibraryBuilt -> JannoLibraryBuilt -> Bool
>= :: JannoLibraryBuilt -> JannoLibraryBuilt -> Bool
$cmax :: JannoLibraryBuilt -> JannoLibraryBuilt -> JannoLibraryBuilt
max :: JannoLibraryBuilt -> JannoLibraryBuilt -> JannoLibraryBuilt
$cmin :: JannoLibraryBuilt -> JannoLibraryBuilt -> JannoLibraryBuilt
min :: JannoLibraryBuilt -> JannoLibraryBuilt -> JannoLibraryBuilt
Ord, (forall x. JannoLibraryBuilt -> Rep JannoLibraryBuilt x)
-> (forall x. Rep JannoLibraryBuilt x -> JannoLibraryBuilt)
-> Generic JannoLibraryBuilt
forall x. Rep JannoLibraryBuilt x -> JannoLibraryBuilt
forall x. JannoLibraryBuilt -> Rep JannoLibraryBuilt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoLibraryBuilt -> Rep JannoLibraryBuilt x
from :: forall x. JannoLibraryBuilt -> Rep JannoLibraryBuilt x
$cto :: forall x. Rep JannoLibraryBuilt x -> JannoLibraryBuilt
to :: forall x. Rep JannoLibraryBuilt x -> JannoLibraryBuilt
Generic, Int -> JannoLibraryBuilt
JannoLibraryBuilt -> Int
JannoLibraryBuilt -> [JannoLibraryBuilt]
JannoLibraryBuilt -> JannoLibraryBuilt
JannoLibraryBuilt -> JannoLibraryBuilt -> [JannoLibraryBuilt]
JannoLibraryBuilt
-> JannoLibraryBuilt -> JannoLibraryBuilt -> [JannoLibraryBuilt]
(JannoLibraryBuilt -> JannoLibraryBuilt)
-> (JannoLibraryBuilt -> JannoLibraryBuilt)
-> (Int -> JannoLibraryBuilt)
-> (JannoLibraryBuilt -> Int)
-> (JannoLibraryBuilt -> [JannoLibraryBuilt])
-> (JannoLibraryBuilt -> JannoLibraryBuilt -> [JannoLibraryBuilt])
-> (JannoLibraryBuilt -> JannoLibraryBuilt -> [JannoLibraryBuilt])
-> (JannoLibraryBuilt
    -> JannoLibraryBuilt -> JannoLibraryBuilt -> [JannoLibraryBuilt])
-> Enum JannoLibraryBuilt
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: JannoLibraryBuilt -> JannoLibraryBuilt
succ :: JannoLibraryBuilt -> JannoLibraryBuilt
$cpred :: JannoLibraryBuilt -> JannoLibraryBuilt
pred :: JannoLibraryBuilt -> JannoLibraryBuilt
$ctoEnum :: Int -> JannoLibraryBuilt
toEnum :: Int -> JannoLibraryBuilt
$cfromEnum :: JannoLibraryBuilt -> Int
fromEnum :: JannoLibraryBuilt -> Int
$cenumFrom :: JannoLibraryBuilt -> [JannoLibraryBuilt]
enumFrom :: JannoLibraryBuilt -> [JannoLibraryBuilt]
$cenumFromThen :: JannoLibraryBuilt -> JannoLibraryBuilt -> [JannoLibraryBuilt]
enumFromThen :: JannoLibraryBuilt -> JannoLibraryBuilt -> [JannoLibraryBuilt]
$cenumFromTo :: JannoLibraryBuilt -> JannoLibraryBuilt -> [JannoLibraryBuilt]
enumFromTo :: JannoLibraryBuilt -> JannoLibraryBuilt -> [JannoLibraryBuilt]
$cenumFromThenTo :: JannoLibraryBuilt
-> JannoLibraryBuilt -> JannoLibraryBuilt -> [JannoLibraryBuilt]
enumFromThenTo :: JannoLibraryBuilt
-> JannoLibraryBuilt -> JannoLibraryBuilt -> [JannoLibraryBuilt]
Enum, JannoLibraryBuilt
JannoLibraryBuilt -> JannoLibraryBuilt -> Bounded JannoLibraryBuilt
forall a. a -> a -> Bounded a
$cminBound :: JannoLibraryBuilt
minBound :: JannoLibraryBuilt
$cmaxBound :: JannoLibraryBuilt
maxBound :: JannoLibraryBuilt
Bounded)

instance Makeable JannoLibraryBuilt where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoLibraryBuilt
make PoseidonVersion
_ Text
x
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"ds"    = JannoLibraryBuilt -> m JannoLibraryBuilt
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoLibraryBuilt
DS
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"ss"    = JannoLibraryBuilt -> m JannoLibraryBuilt
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoLibraryBuilt
SS
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"mixed" = JannoLibraryBuilt -> m JannoLibraryBuilt
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoLibraryBuilt
MixedSSDS
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"other" = JannoLibraryBuilt -> m JannoLibraryBuilt
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoLibraryBuilt
Other
        | Bool
otherwise    = [Char] -> m JannoLibraryBuilt
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoLibraryBuilt) -> [Char] -> m JannoLibraryBuilt
forall a b. (a -> b) -> a -> b
$ [Char]
"Library_Built is set to " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
". " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
                                [Char]
"That is not in the allowed set [ds, ss, mixed]."
instance Suspicious JannoLibraryBuilt where inspect :: JannoLibraryBuilt -> Maybe [[Char]]
inspect JannoLibraryBuilt
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoLibraryBuilt where
    show :: JannoLibraryBuilt -> [Char]
show JannoLibraryBuilt
DS        = [Char]
"ds"
    show JannoLibraryBuilt
SS        = [Char]
"ss"
    show JannoLibraryBuilt
MixedSSDS = [Char]
"mixed"
    show JannoLibraryBuilt
Other     = [Char]
"other"
instance Csv.ToField JannoLibraryBuilt where   toField :: JannoLibraryBuilt -> Field
toField JannoLibraryBuilt
x = [Char] -> Field
forall a. ToField a => a -> Field
Csv.toField ([Char] -> Field) -> [Char] -> Field
forall a b. (a -> b) -> a -> b
$ JannoLibraryBuilt -> [Char]
forall a. Show a => a -> [Char]
show JannoLibraryBuilt
x
instance FromFieldVersioned JannoLibraryBuilt where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoLibraryBuilt
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoLibraryBuilt
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Library_Built"

-- | A datatype for the Genotype_Ploidy .janno column
data JannoGenotypePloidy =
      Diploid
    | Haploid
    deriving (JannoGenotypePloidy -> JannoGenotypePloidy -> Bool
(JannoGenotypePloidy -> JannoGenotypePloidy -> Bool)
-> (JannoGenotypePloidy -> JannoGenotypePloidy -> Bool)
-> Eq JannoGenotypePloidy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoGenotypePloidy -> JannoGenotypePloidy -> Bool
== :: JannoGenotypePloidy -> JannoGenotypePloidy -> Bool
$c/= :: JannoGenotypePloidy -> JannoGenotypePloidy -> Bool
/= :: JannoGenotypePloidy -> JannoGenotypePloidy -> Bool
Eq, Eq JannoGenotypePloidy
Eq JannoGenotypePloidy =>
(JannoGenotypePloidy -> JannoGenotypePloidy -> Ordering)
-> (JannoGenotypePloidy -> JannoGenotypePloidy -> Bool)
-> (JannoGenotypePloidy -> JannoGenotypePloidy -> Bool)
-> (JannoGenotypePloidy -> JannoGenotypePloidy -> Bool)
-> (JannoGenotypePloidy -> JannoGenotypePloidy -> Bool)
-> (JannoGenotypePloidy
    -> JannoGenotypePloidy -> JannoGenotypePloidy)
-> (JannoGenotypePloidy
    -> JannoGenotypePloidy -> JannoGenotypePloidy)
-> Ord JannoGenotypePloidy
JannoGenotypePloidy -> JannoGenotypePloidy -> Bool
JannoGenotypePloidy -> JannoGenotypePloidy -> Ordering
JannoGenotypePloidy -> JannoGenotypePloidy -> JannoGenotypePloidy
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
$ccompare :: JannoGenotypePloidy -> JannoGenotypePloidy -> Ordering
compare :: JannoGenotypePloidy -> JannoGenotypePloidy -> Ordering
$c< :: JannoGenotypePloidy -> JannoGenotypePloidy -> Bool
< :: JannoGenotypePloidy -> JannoGenotypePloidy -> Bool
$c<= :: JannoGenotypePloidy -> JannoGenotypePloidy -> Bool
<= :: JannoGenotypePloidy -> JannoGenotypePloidy -> Bool
$c> :: JannoGenotypePloidy -> JannoGenotypePloidy -> Bool
> :: JannoGenotypePloidy -> JannoGenotypePloidy -> Bool
$c>= :: JannoGenotypePloidy -> JannoGenotypePloidy -> Bool
>= :: JannoGenotypePloidy -> JannoGenotypePloidy -> Bool
$cmax :: JannoGenotypePloidy -> JannoGenotypePloidy -> JannoGenotypePloidy
max :: JannoGenotypePloidy -> JannoGenotypePloidy -> JannoGenotypePloidy
$cmin :: JannoGenotypePloidy -> JannoGenotypePloidy -> JannoGenotypePloidy
min :: JannoGenotypePloidy -> JannoGenotypePloidy -> JannoGenotypePloidy
Ord, (forall x. JannoGenotypePloidy -> Rep JannoGenotypePloidy x)
-> (forall x. Rep JannoGenotypePloidy x -> JannoGenotypePloidy)
-> Generic JannoGenotypePloidy
forall x. Rep JannoGenotypePloidy x -> JannoGenotypePloidy
forall x. JannoGenotypePloidy -> Rep JannoGenotypePloidy x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoGenotypePloidy -> Rep JannoGenotypePloidy x
from :: forall x. JannoGenotypePloidy -> Rep JannoGenotypePloidy x
$cto :: forall x. Rep JannoGenotypePloidy x -> JannoGenotypePloidy
to :: forall x. Rep JannoGenotypePloidy x -> JannoGenotypePloidy
Generic, Int -> JannoGenotypePloidy
JannoGenotypePloidy -> Int
JannoGenotypePloidy -> [JannoGenotypePloidy]
JannoGenotypePloidy -> JannoGenotypePloidy
JannoGenotypePloidy -> JannoGenotypePloidy -> [JannoGenotypePloidy]
JannoGenotypePloidy
-> JannoGenotypePloidy
-> JannoGenotypePloidy
-> [JannoGenotypePloidy]
(JannoGenotypePloidy -> JannoGenotypePloidy)
-> (JannoGenotypePloidy -> JannoGenotypePloidy)
-> (Int -> JannoGenotypePloidy)
-> (JannoGenotypePloidy -> Int)
-> (JannoGenotypePloidy -> [JannoGenotypePloidy])
-> (JannoGenotypePloidy
    -> JannoGenotypePloidy -> [JannoGenotypePloidy])
-> (JannoGenotypePloidy
    -> JannoGenotypePloidy -> [JannoGenotypePloidy])
-> (JannoGenotypePloidy
    -> JannoGenotypePloidy
    -> JannoGenotypePloidy
    -> [JannoGenotypePloidy])
-> Enum JannoGenotypePloidy
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: JannoGenotypePloidy -> JannoGenotypePloidy
succ :: JannoGenotypePloidy -> JannoGenotypePloidy
$cpred :: JannoGenotypePloidy -> JannoGenotypePloidy
pred :: JannoGenotypePloidy -> JannoGenotypePloidy
$ctoEnum :: Int -> JannoGenotypePloidy
toEnum :: Int -> JannoGenotypePloidy
$cfromEnum :: JannoGenotypePloidy -> Int
fromEnum :: JannoGenotypePloidy -> Int
$cenumFrom :: JannoGenotypePloidy -> [JannoGenotypePloidy]
enumFrom :: JannoGenotypePloidy -> [JannoGenotypePloidy]
$cenumFromThen :: JannoGenotypePloidy -> JannoGenotypePloidy -> [JannoGenotypePloidy]
enumFromThen :: JannoGenotypePloidy -> JannoGenotypePloidy -> [JannoGenotypePloidy]
$cenumFromTo :: JannoGenotypePloidy -> JannoGenotypePloidy -> [JannoGenotypePloidy]
enumFromTo :: JannoGenotypePloidy -> JannoGenotypePloidy -> [JannoGenotypePloidy]
$cenumFromThenTo :: JannoGenotypePloidy
-> JannoGenotypePloidy
-> JannoGenotypePloidy
-> [JannoGenotypePloidy]
enumFromThenTo :: JannoGenotypePloidy
-> JannoGenotypePloidy
-> JannoGenotypePloidy
-> [JannoGenotypePloidy]
Enum, JannoGenotypePloidy
JannoGenotypePloidy
-> JannoGenotypePloidy -> Bounded JannoGenotypePloidy
forall a. a -> a -> Bounded a
$cminBound :: JannoGenotypePloidy
minBound :: JannoGenotypePloidy
$cmaxBound :: JannoGenotypePloidy
maxBound :: JannoGenotypePloidy
Bounded)

instance Makeable JannoGenotypePloidy where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoGenotypePloidy
make PoseidonVersion
_ Text
x
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"diploid" = JannoGenotypePloidy -> m JannoGenotypePloidy
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoGenotypePloidy
Diploid
        | Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"haploid" = JannoGenotypePloidy -> m JannoGenotypePloidy
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoGenotypePloidy
Haploid
        | Bool
otherwise      = [Char] -> m JannoGenotypePloidy
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoGenotypePloidy)
-> [Char] -> m JannoGenotypePloidy
forall a b. (a -> b) -> a -> b
$ [Char]
"Genotype_Ploidy is set to " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
". " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
                                  [Char]
"That is not in the allowed set [diploid, haploid]."
instance Suspicious JannoGenotypePloidy where inspect :: JannoGenotypePloidy -> Maybe [[Char]]
inspect JannoGenotypePloidy
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoGenotypePloidy where
    show :: JannoGenotypePloidy -> [Char]
show JannoGenotypePloidy
Diploid = [Char]
"diploid"
    show JannoGenotypePloidy
Haploid = [Char]
"haploid"
instance Csv.ToField JannoGenotypePloidy where   toField :: JannoGenotypePloidy -> Field
toField JannoGenotypePloidy
x = [Char] -> Field
forall a. ToField a => a -> Field
Csv.toField ([Char] -> Field) -> [Char] -> Field
forall a b. (a -> b) -> a -> b
$ JannoGenotypePloidy -> [Char]
forall a. Show a => a -> [Char]
show JannoGenotypePloidy
x
instance FromFieldVersioned JannoGenotypePloidy where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoGenotypePloidy
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoGenotypePloidy
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Genotype_Ploidy"

-- | A datatype for the Genotype_Ploidy .janno column
newtype JannoDataPreparationPipelineURL = JannoDataPreparationPipelineURL T.Text deriving (JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL -> Bool
(JannoDataPreparationPipelineURL
 -> JannoDataPreparationPipelineURL -> Bool)
-> (JannoDataPreparationPipelineURL
    -> JannoDataPreparationPipelineURL -> Bool)
-> Eq JannoDataPreparationPipelineURL
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL -> Bool
== :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL -> Bool
$c/= :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL -> Bool
/= :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL -> Bool
Eq, Eq JannoDataPreparationPipelineURL
Eq JannoDataPreparationPipelineURL =>
(JannoDataPreparationPipelineURL
 -> JannoDataPreparationPipelineURL -> Ordering)
-> (JannoDataPreparationPipelineURL
    -> JannoDataPreparationPipelineURL -> Bool)
-> (JannoDataPreparationPipelineURL
    -> JannoDataPreparationPipelineURL -> Bool)
-> (JannoDataPreparationPipelineURL
    -> JannoDataPreparationPipelineURL -> Bool)
-> (JannoDataPreparationPipelineURL
    -> JannoDataPreparationPipelineURL -> Bool)
-> (JannoDataPreparationPipelineURL
    -> JannoDataPreparationPipelineURL
    -> JannoDataPreparationPipelineURL)
-> (JannoDataPreparationPipelineURL
    -> JannoDataPreparationPipelineURL
    -> JannoDataPreparationPipelineURL)
-> Ord JannoDataPreparationPipelineURL
JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL -> Bool
JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL -> Ordering
JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL
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
$ccompare :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL -> Ordering
compare :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL -> Ordering
$c< :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL -> Bool
< :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL -> Bool
$c<= :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL -> Bool
<= :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL -> Bool
$c> :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL -> Bool
> :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL -> Bool
$c>= :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL -> Bool
>= :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL -> Bool
$cmax :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL
max :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL
$cmin :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL
min :: JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL
-> JannoDataPreparationPipelineURL
Ord, (forall x.
 JannoDataPreparationPipelineURL
 -> Rep JannoDataPreparationPipelineURL x)
-> (forall x.
    Rep JannoDataPreparationPipelineURL x
    -> JannoDataPreparationPipelineURL)
-> Generic JannoDataPreparationPipelineURL
forall x.
Rep JannoDataPreparationPipelineURL x
-> JannoDataPreparationPipelineURL
forall x.
JannoDataPreparationPipelineURL
-> Rep JannoDataPreparationPipelineURL x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
JannoDataPreparationPipelineURL
-> Rep JannoDataPreparationPipelineURL x
from :: forall x.
JannoDataPreparationPipelineURL
-> Rep JannoDataPreparationPipelineURL x
$cto :: forall x.
Rep JannoDataPreparationPipelineURL x
-> JannoDataPreparationPipelineURL
to :: forall x.
Rep JannoDataPreparationPipelineURL x
-> JannoDataPreparationPipelineURL
Generic)

instance Makeable JannoDataPreparationPipelineURL where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoDataPreparationPipelineURL
make PoseidonVersion
_ Text
x
        | [Char] -> Bool
isURIReference (Text -> [Char]
T.unpack Text
x) = JannoDataPreparationPipelineURL
-> m JannoDataPreparationPipelineURL
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (JannoDataPreparationPipelineURL
 -> m JannoDataPreparationPipelineURL)
-> JannoDataPreparationPipelineURL
-> m JannoDataPreparationPipelineURL
forall a b. (a -> b) -> a -> b
$ Text -> JannoDataPreparationPipelineURL
JannoDataPreparationPipelineURL Text
x
        | Bool
otherwise                   = [Char] -> m JannoDataPreparationPipelineURL
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDataPreparationPipelineURL)
-> [Char] -> m JannoDataPreparationPipelineURL
forall a b. (a -> b) -> a -> b
$ [Char]
"Data_Preparation_Pipeline_URL " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" is not a well structured URI."
instance Suspicious JannoDataPreparationPipelineURL where inspect :: JannoDataPreparationPipelineURL -> Maybe [[Char]]
inspect JannoDataPreparationPipelineURL
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoDataPreparationPipelineURL where          show :: JannoDataPreparationPipelineURL -> [Char]
show (JannoDataPreparationPipelineURL Text
x) = Text -> [Char]
T.unpack Text
x
instance Csv.ToField JannoDataPreparationPipelineURL where   toField :: JannoDataPreparationPipelineURL -> Field
toField (JannoDataPreparationPipelineURL Text
x) = Text -> Field
forall a. ToField a => a -> Field
Csv.toField Text
x
instance FromFieldVersioned JannoDataPreparationPipelineURL where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoDataPreparationPipelineURL
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion
-> [Char] -> Field -> Parser JannoDataPreparationPipelineURL
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Data_Preparation_Pipeline_URL"

-- | A datatype for the Endogenous .janno column
newtype JannoEndogenous = JannoEndogenous Double deriving (JannoEndogenous -> JannoEndogenous -> Bool
(JannoEndogenous -> JannoEndogenous -> Bool)
-> (JannoEndogenous -> JannoEndogenous -> Bool)
-> Eq JannoEndogenous
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoEndogenous -> JannoEndogenous -> Bool
== :: JannoEndogenous -> JannoEndogenous -> Bool
$c/= :: JannoEndogenous -> JannoEndogenous -> Bool
/= :: JannoEndogenous -> JannoEndogenous -> Bool
Eq, Eq JannoEndogenous
Eq JannoEndogenous =>
(JannoEndogenous -> JannoEndogenous -> Ordering)
-> (JannoEndogenous -> JannoEndogenous -> Bool)
-> (JannoEndogenous -> JannoEndogenous -> Bool)
-> (JannoEndogenous -> JannoEndogenous -> Bool)
-> (JannoEndogenous -> JannoEndogenous -> Bool)
-> (JannoEndogenous -> JannoEndogenous -> JannoEndogenous)
-> (JannoEndogenous -> JannoEndogenous -> JannoEndogenous)
-> Ord JannoEndogenous
JannoEndogenous -> JannoEndogenous -> Bool
JannoEndogenous -> JannoEndogenous -> Ordering
JannoEndogenous -> JannoEndogenous -> JannoEndogenous
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
$ccompare :: JannoEndogenous -> JannoEndogenous -> Ordering
compare :: JannoEndogenous -> JannoEndogenous -> Ordering
$c< :: JannoEndogenous -> JannoEndogenous -> Bool
< :: JannoEndogenous -> JannoEndogenous -> Bool
$c<= :: JannoEndogenous -> JannoEndogenous -> Bool
<= :: JannoEndogenous -> JannoEndogenous -> Bool
$c> :: JannoEndogenous -> JannoEndogenous -> Bool
> :: JannoEndogenous -> JannoEndogenous -> Bool
$c>= :: JannoEndogenous -> JannoEndogenous -> Bool
>= :: JannoEndogenous -> JannoEndogenous -> Bool
$cmax :: JannoEndogenous -> JannoEndogenous -> JannoEndogenous
max :: JannoEndogenous -> JannoEndogenous -> JannoEndogenous
$cmin :: JannoEndogenous -> JannoEndogenous -> JannoEndogenous
min :: JannoEndogenous -> JannoEndogenous -> JannoEndogenous
Ord, (forall x. JannoEndogenous -> Rep JannoEndogenous x)
-> (forall x. Rep JannoEndogenous x -> JannoEndogenous)
-> Generic JannoEndogenous
forall x. Rep JannoEndogenous x -> JannoEndogenous
forall x. JannoEndogenous -> Rep JannoEndogenous x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoEndogenous -> Rep JannoEndogenous x
from :: forall x. JannoEndogenous -> Rep JannoEndogenous x
$cto :: forall x. Rep JannoEndogenous x -> JannoEndogenous
to :: forall x. Rep JannoEndogenous x -> JannoEndogenous
Generic)

instance Makeable JannoEndogenous where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoEndogenous
make PoseidonVersion
pv Text
x =
        case Reader Double
T.double Text
x of
            Left [Char]
e -> [Char] -> m JannoEndogenous
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoEndogenous) -> [Char] -> m JannoEndogenous
forall a b. (a -> b) -> a -> b
$ [Char]
"Endogenous can not be converted to Double because " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
e
            Right (Double
num, Text
"") ->
                if PoseidonVersion -> Version
asVersion PoseidonVersion
pv Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
>= [Int] -> Version
makeVersion [Int
3,Int
0,Int
0]
                then do
                    if Double
num Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= Double
0 Bool -> Bool -> Bool
&& Double
num Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<= Double
1
                    then JannoEndogenous -> m JannoEndogenous
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> JannoEndogenous
JannoEndogenous Double
num)
                    else [Char] -> m JannoEndogenous
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoEndogenous) -> [Char] -> m JannoEndogenous
forall a b. (a -> b) -> a -> b
$ [Char]
"Endogenous " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" not between 0 and 1."
                else do
                    if Double
num Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= Double
0 Bool -> Bool -> Bool
&& Double
num Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<= Double
100
                    then JannoEndogenous -> m JannoEndogenous
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> JannoEndogenous
JannoEndogenous (Double -> JannoEndogenous) -> Double -> JannoEndogenous
forall a b. (a -> b) -> a -> b
$ Double
num Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
100) -- rescale to 0-1
                    else [Char] -> m JannoEndogenous
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoEndogenous) -> [Char] -> m JannoEndogenous
forall a b. (a -> b) -> a -> b
$ [Char]
"Endogenous " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" not between 0 and 100."
            Right (Double
_, Text
rest) -> [Char] -> m JannoEndogenous
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoEndogenous) -> [Char] -> m JannoEndogenous
forall a b. (a -> b) -> a -> b
$ [Char]
"Endogenous can not be converted to Double, because of a trailing " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
rest
instance Suspicious JannoEndogenous where inspect :: JannoEndogenous -> Maybe [[Char]]
inspect JannoEndogenous
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoEndogenous where          show :: JannoEndogenous -> [Char]
show (JannoEndogenous Double
x) = Double -> [Char]
forall a. Show a => a -> [Char]
show Double
x
instance Csv.ToField JannoEndogenous where   toField :: JannoEndogenous -> Field
toField (JannoEndogenous Double
x) = Double -> Field
forall a. ToField a => a -> Field
Csv.toField Double
x
instance FromFieldVersioned JannoEndogenous where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoEndogenous
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoEndogenous
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Endogenous"

-- | A datatype for the Nr_SNPs .janno column
newtype JannoNrSNPs = JannoNrSNPs Int deriving (JannoNrSNPs -> JannoNrSNPs -> Bool
(JannoNrSNPs -> JannoNrSNPs -> Bool)
-> (JannoNrSNPs -> JannoNrSNPs -> Bool) -> Eq JannoNrSNPs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoNrSNPs -> JannoNrSNPs -> Bool
== :: JannoNrSNPs -> JannoNrSNPs -> Bool
$c/= :: JannoNrSNPs -> JannoNrSNPs -> Bool
/= :: JannoNrSNPs -> JannoNrSNPs -> Bool
Eq, Eq JannoNrSNPs
Eq JannoNrSNPs =>
(JannoNrSNPs -> JannoNrSNPs -> Ordering)
-> (JannoNrSNPs -> JannoNrSNPs -> Bool)
-> (JannoNrSNPs -> JannoNrSNPs -> Bool)
-> (JannoNrSNPs -> JannoNrSNPs -> Bool)
-> (JannoNrSNPs -> JannoNrSNPs -> Bool)
-> (JannoNrSNPs -> JannoNrSNPs -> JannoNrSNPs)
-> (JannoNrSNPs -> JannoNrSNPs -> JannoNrSNPs)
-> Ord JannoNrSNPs
JannoNrSNPs -> JannoNrSNPs -> Bool
JannoNrSNPs -> JannoNrSNPs -> Ordering
JannoNrSNPs -> JannoNrSNPs -> JannoNrSNPs
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
$ccompare :: JannoNrSNPs -> JannoNrSNPs -> Ordering
compare :: JannoNrSNPs -> JannoNrSNPs -> Ordering
$c< :: JannoNrSNPs -> JannoNrSNPs -> Bool
< :: JannoNrSNPs -> JannoNrSNPs -> Bool
$c<= :: JannoNrSNPs -> JannoNrSNPs -> Bool
<= :: JannoNrSNPs -> JannoNrSNPs -> Bool
$c> :: JannoNrSNPs -> JannoNrSNPs -> Bool
> :: JannoNrSNPs -> JannoNrSNPs -> Bool
$c>= :: JannoNrSNPs -> JannoNrSNPs -> Bool
>= :: JannoNrSNPs -> JannoNrSNPs -> Bool
$cmax :: JannoNrSNPs -> JannoNrSNPs -> JannoNrSNPs
max :: JannoNrSNPs -> JannoNrSNPs -> JannoNrSNPs
$cmin :: JannoNrSNPs -> JannoNrSNPs -> JannoNrSNPs
min :: JannoNrSNPs -> JannoNrSNPs -> JannoNrSNPs
Ord, (forall x. JannoNrSNPs -> Rep JannoNrSNPs x)
-> (forall x. Rep JannoNrSNPs x -> JannoNrSNPs)
-> Generic JannoNrSNPs
forall x. Rep JannoNrSNPs x -> JannoNrSNPs
forall x. JannoNrSNPs -> Rep JannoNrSNPs x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoNrSNPs -> Rep JannoNrSNPs x
from :: forall x. JannoNrSNPs -> Rep JannoNrSNPs x
$cto :: forall x. Rep JannoNrSNPs x -> JannoNrSNPs
to :: forall x. Rep JannoNrSNPs x -> JannoNrSNPs
Generic)

instance Makeable JannoNrSNPs where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoNrSNPs
make PoseidonVersion
_ Text
x =
        case Reader Int -> Reader Int
forall a. Num a => Reader a -> Reader a
T.signed Reader Int
forall a. Integral a => Reader a
T.decimal Text
x of
            Left [Char]
e -> [Char] -> m JannoNrSNPs
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoNrSNPs) -> [Char] -> m JannoNrSNPs
forall a b. (a -> b) -> a -> b
$ [Char]
"Nr_SNPs can not be converted to Int because " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
e
            Right (Int
num, Text
"") ->
                if Int
num Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0
                then [Char] -> m JannoNrSNPs
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoNrSNPs) -> [Char] -> m JannoNrSNPs
forall a b. (a -> b) -> a -> b
$ [Char]
"Nr_SNPs " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" lower than 0, which is not meaningful."
                else JannoNrSNPs -> m JannoNrSNPs
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (JannoNrSNPs -> m JannoNrSNPs) -> JannoNrSNPs -> m JannoNrSNPs
forall a b. (a -> b) -> a -> b
$ Int -> JannoNrSNPs
JannoNrSNPs Int
num
            Right (Int
_, Text
rest) -> [Char] -> m JannoNrSNPs
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoNrSNPs) -> [Char] -> m JannoNrSNPs
forall a b. (a -> b) -> a -> b
$ [Char]
"Nr_SNPs can not be converted to Int, because of a trailing " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
rest
instance Suspicious JannoNrSNPs where
    inspect :: JannoNrSNPs -> Maybe [[Char]]
inspect (JannoNrSNPs Int
x)
        | Int
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = [[Char]] -> Maybe [[Char]]
forall a. a -> Maybe a
Just [[Char]
"Nr_SNPs is set to 0, indicating no recorded SNPs in the genotype data."]
        | Bool
otherwise = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoNrSNPs where          show :: JannoNrSNPs -> [Char]
show (JannoNrSNPs Int
x) = Int -> [Char]
forall a. Show a => a -> [Char]
show Int
x
instance Csv.ToField JannoNrSNPs where   toField :: JannoNrSNPs -> Field
toField (JannoNrSNPs Int
x) = Int -> Field
forall a. ToField a => a -> Field
Csv.toField Int
x
instance FromFieldVersioned JannoNrSNPs where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoNrSNPs
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoNrSNPs
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Nr_SNPs"

-- | A datatype for the Coverage_on_Target_SNPs .janno column
newtype JannoCoverageOnTargets = JannoCoverageOnTargets Double deriving (JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool
(JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool)
-> (JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool)
-> Eq JannoCoverageOnTargets
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool
== :: JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool
$c/= :: JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool
/= :: JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool
Eq, Eq JannoCoverageOnTargets
Eq JannoCoverageOnTargets =>
(JannoCoverageOnTargets -> JannoCoverageOnTargets -> Ordering)
-> (JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool)
-> (JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool)
-> (JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool)
-> (JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool)
-> (JannoCoverageOnTargets
    -> JannoCoverageOnTargets -> JannoCoverageOnTargets)
-> (JannoCoverageOnTargets
    -> JannoCoverageOnTargets -> JannoCoverageOnTargets)
-> Ord JannoCoverageOnTargets
JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool
JannoCoverageOnTargets -> JannoCoverageOnTargets -> Ordering
JannoCoverageOnTargets
-> JannoCoverageOnTargets -> JannoCoverageOnTargets
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
$ccompare :: JannoCoverageOnTargets -> JannoCoverageOnTargets -> Ordering
compare :: JannoCoverageOnTargets -> JannoCoverageOnTargets -> Ordering
$c< :: JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool
< :: JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool
$c<= :: JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool
<= :: JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool
$c> :: JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool
> :: JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool
$c>= :: JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool
>= :: JannoCoverageOnTargets -> JannoCoverageOnTargets -> Bool
$cmax :: JannoCoverageOnTargets
-> JannoCoverageOnTargets -> JannoCoverageOnTargets
max :: JannoCoverageOnTargets
-> JannoCoverageOnTargets -> JannoCoverageOnTargets
$cmin :: JannoCoverageOnTargets
-> JannoCoverageOnTargets -> JannoCoverageOnTargets
min :: JannoCoverageOnTargets
-> JannoCoverageOnTargets -> JannoCoverageOnTargets
Ord, (forall x. JannoCoverageOnTargets -> Rep JannoCoverageOnTargets x)
-> (forall x.
    Rep JannoCoverageOnTargets x -> JannoCoverageOnTargets)
-> Generic JannoCoverageOnTargets
forall x. Rep JannoCoverageOnTargets x -> JannoCoverageOnTargets
forall x. JannoCoverageOnTargets -> Rep JannoCoverageOnTargets x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoCoverageOnTargets -> Rep JannoCoverageOnTargets x
from :: forall x. JannoCoverageOnTargets -> Rep JannoCoverageOnTargets x
$cto :: forall x. Rep JannoCoverageOnTargets x -> JannoCoverageOnTargets
to :: forall x. Rep JannoCoverageOnTargets x -> JannoCoverageOnTargets
Generic)

instance Makeable JannoCoverageOnTargets where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoCoverageOnTargets
make PoseidonVersion
_ Text
x =
        case Reader Double
T.double Text
x of
            Left [Char]
e -> [Char] -> m JannoCoverageOnTargets
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoCoverageOnTargets)
-> [Char] -> m JannoCoverageOnTargets
forall a b. (a -> b) -> a -> b
$ [Char]
"Coverage_on_Target_SNPs can not be converted to Double because " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
e
            Right (Double
num, Text
"") ->  JannoCoverageOnTargets -> m JannoCoverageOnTargets
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> JannoCoverageOnTargets
JannoCoverageOnTargets Double
num)
            Right (Double
_, Text
rest) -> [Char] -> m JannoCoverageOnTargets
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoCoverageOnTargets)
-> [Char] -> m JannoCoverageOnTargets
forall a b. (a -> b) -> a -> b
$ [Char]
"Coverage_on_Target_SNPs can not be converted to Double, because of a trailing " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
rest
instance Suspicious JannoCoverageOnTargets where inspect :: JannoCoverageOnTargets -> Maybe [[Char]]
inspect JannoCoverageOnTargets
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoCoverageOnTargets where          show :: JannoCoverageOnTargets -> [Char]
show (JannoCoverageOnTargets Double
x) = Double -> [Char]
forall a. Show a => a -> [Char]
show Double
x
instance Csv.ToField JannoCoverageOnTargets where   toField :: JannoCoverageOnTargets -> Field
toField (JannoCoverageOnTargets Double
x) = Double -> Field
forall a. ToField a => a -> Field
Csv.toField Double
x
instance FromFieldVersioned JannoCoverageOnTargets where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoCoverageOnTargets
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoCoverageOnTargets
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Coverage_on_Target_SNPs"

-- | A datatype for the Damage .janno column
newtype JannoDamage = JannoDamage Double deriving (JannoDamage -> JannoDamage -> Bool
(JannoDamage -> JannoDamage -> Bool)
-> (JannoDamage -> JannoDamage -> Bool) -> Eq JannoDamage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoDamage -> JannoDamage -> Bool
== :: JannoDamage -> JannoDamage -> Bool
$c/= :: JannoDamage -> JannoDamage -> Bool
/= :: JannoDamage -> JannoDamage -> Bool
Eq, Eq JannoDamage
Eq JannoDamage =>
(JannoDamage -> JannoDamage -> Ordering)
-> (JannoDamage -> JannoDamage -> Bool)
-> (JannoDamage -> JannoDamage -> Bool)
-> (JannoDamage -> JannoDamage -> Bool)
-> (JannoDamage -> JannoDamage -> Bool)
-> (JannoDamage -> JannoDamage -> JannoDamage)
-> (JannoDamage -> JannoDamage -> JannoDamage)
-> Ord JannoDamage
JannoDamage -> JannoDamage -> Bool
JannoDamage -> JannoDamage -> Ordering
JannoDamage -> JannoDamage -> JannoDamage
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
$ccompare :: JannoDamage -> JannoDamage -> Ordering
compare :: JannoDamage -> JannoDamage -> Ordering
$c< :: JannoDamage -> JannoDamage -> Bool
< :: JannoDamage -> JannoDamage -> Bool
$c<= :: JannoDamage -> JannoDamage -> Bool
<= :: JannoDamage -> JannoDamage -> Bool
$c> :: JannoDamage -> JannoDamage -> Bool
> :: JannoDamage -> JannoDamage -> Bool
$c>= :: JannoDamage -> JannoDamage -> Bool
>= :: JannoDamage -> JannoDamage -> Bool
$cmax :: JannoDamage -> JannoDamage -> JannoDamage
max :: JannoDamage -> JannoDamage -> JannoDamage
$cmin :: JannoDamage -> JannoDamage -> JannoDamage
min :: JannoDamage -> JannoDamage -> JannoDamage
Ord, (forall x. JannoDamage -> Rep JannoDamage x)
-> (forall x. Rep JannoDamage x -> JannoDamage)
-> Generic JannoDamage
forall x. Rep JannoDamage x -> JannoDamage
forall x. JannoDamage -> Rep JannoDamage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoDamage -> Rep JannoDamage x
from :: forall x. JannoDamage -> Rep JannoDamage x
$cto :: forall x. Rep JannoDamage x -> JannoDamage
to :: forall x. Rep JannoDamage x -> JannoDamage
Generic)

instance Makeable JannoDamage where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoDamage
make PoseidonVersion
pv Text
x =
        case Reader Double
T.double Text
x of
            Left [Char]
e -> [Char] -> m JannoDamage
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDamage) -> [Char] -> m JannoDamage
forall a b. (a -> b) -> a -> b
$ [Char]
"Damage can not be converted to Double because " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
e
            Right (Double
num, Text
"") ->
                if PoseidonVersion -> Version
asVersion PoseidonVersion
pv Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
>= [Int] -> Version
makeVersion [Int
3,Int
0,Int
0]
                then do
                    if Double
num Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= Double
0 Bool -> Bool -> Bool
&& Double
num Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<= Double
1
                    then JannoDamage -> m JannoDamage
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> JannoDamage
JannoDamage Double
num)
                    else [Char] -> m JannoDamage
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDamage) -> [Char] -> m JannoDamage
forall a b. (a -> b) -> a -> b
$ [Char]
"Damage " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" not between 0 and 1."
                else do
                    if Double
num Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= Double
0 Bool -> Bool -> Bool
&& Double
num Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<= Double
100
                    then JannoDamage -> m JannoDamage
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> JannoDamage
JannoDamage (Double -> JannoDamage) -> Double -> JannoDamage
forall a b. (a -> b) -> a -> b
$ Double
num Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
100) -- rescale to 0-1
                    else [Char] -> m JannoDamage
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDamage) -> [Char] -> m JannoDamage
forall a b. (a -> b) -> a -> b
$ [Char]
"Damage " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" not between 0 and 100."
            Right (Double
_, Text
rest) -> [Char] -> m JannoDamage
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m JannoDamage) -> [Char] -> m JannoDamage
forall a b. (a -> b) -> a -> b
$ [Char]
"Damage can not be converted to Double, because of a trailing " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
rest
instance Suspicious JannoDamage where inspect :: JannoDamage -> Maybe [[Char]]
inspect JannoDamage
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoDamage where          show :: JannoDamage -> [Char]
show (JannoDamage Double
x) = Double -> [Char]
forall a. Show a => a -> [Char]
show Double
x
instance Csv.ToField JannoDamage where   toField :: JannoDamage -> Field
toField (JannoDamage Double
x) = Double -> Field
forall a. ToField a => a -> Field
Csv.toField Double
x
instance FromFieldVersioned JannoDamage where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoDamage
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion -> [Char] -> Field -> Parser JannoDamage
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Damage"

-- | A datatype for the Contamination .janno column
newtype JannoContamination = JannoContamination T.Text deriving (JannoContamination -> JannoContamination -> Bool
(JannoContamination -> JannoContamination -> Bool)
-> (JannoContamination -> JannoContamination -> Bool)
-> Eq JannoContamination
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoContamination -> JannoContamination -> Bool
== :: JannoContamination -> JannoContamination -> Bool
$c/= :: JannoContamination -> JannoContamination -> Bool
/= :: JannoContamination -> JannoContamination -> Bool
Eq)
$(makeInstances ''JannoContamination "Contamination")

-- | A datatype for the Contamination_Err .janno column
newtype JannoContaminationErr = JannoContaminationErr T.Text deriving (JannoContaminationErr -> JannoContaminationErr -> Bool
(JannoContaminationErr -> JannoContaminationErr -> Bool)
-> (JannoContaminationErr -> JannoContaminationErr -> Bool)
-> Eq JannoContaminationErr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoContaminationErr -> JannoContaminationErr -> Bool
== :: JannoContaminationErr -> JannoContaminationErr -> Bool
$c/= :: JannoContaminationErr -> JannoContaminationErr -> Bool
/= :: JannoContaminationErr -> JannoContaminationErr -> Bool
Eq)
$(makeInstances ''JannoContaminationErr "Contamination_Err")

-- | A datatype for the Contamination_Meas .janno column
newtype JannoContaminationMeas = JannoContaminationMeas T.Text deriving (JannoContaminationMeas -> JannoContaminationMeas -> Bool
(JannoContaminationMeas -> JannoContaminationMeas -> Bool)
-> (JannoContaminationMeas -> JannoContaminationMeas -> Bool)
-> Eq JannoContaminationMeas
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoContaminationMeas -> JannoContaminationMeas -> Bool
== :: JannoContaminationMeas -> JannoContaminationMeas -> Bool
$c/= :: JannoContaminationMeas -> JannoContaminationMeas -> Bool
/= :: JannoContaminationMeas -> JannoContaminationMeas -> Bool
Eq)
$(makeInstances ''JannoContaminationMeas "Contamination_Meas")

-- | A datatype for the Genetic_Source_Accession_IDs .janno column
newtype JannoGeneticSourceAccessionID = JannoGeneticSourceAccessionID AccessionID
    deriving (JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> Bool
(JannoGeneticSourceAccessionID
 -> JannoGeneticSourceAccessionID -> Bool)
-> (JannoGeneticSourceAccessionID
    -> JannoGeneticSourceAccessionID -> Bool)
-> Eq JannoGeneticSourceAccessionID
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> Bool
== :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> Bool
$c/= :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> Bool
/= :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> Bool
Eq, Eq JannoGeneticSourceAccessionID
Eq JannoGeneticSourceAccessionID =>
(JannoGeneticSourceAccessionID
 -> JannoGeneticSourceAccessionID -> Ordering)
-> (JannoGeneticSourceAccessionID
    -> JannoGeneticSourceAccessionID -> Bool)
-> (JannoGeneticSourceAccessionID
    -> JannoGeneticSourceAccessionID -> Bool)
-> (JannoGeneticSourceAccessionID
    -> JannoGeneticSourceAccessionID -> Bool)
-> (JannoGeneticSourceAccessionID
    -> JannoGeneticSourceAccessionID -> Bool)
-> (JannoGeneticSourceAccessionID
    -> JannoGeneticSourceAccessionID -> JannoGeneticSourceAccessionID)
-> (JannoGeneticSourceAccessionID
    -> JannoGeneticSourceAccessionID -> JannoGeneticSourceAccessionID)
-> Ord JannoGeneticSourceAccessionID
JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> Bool
JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> Ordering
JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> JannoGeneticSourceAccessionID
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
$ccompare :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> Ordering
compare :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> Ordering
$c< :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> Bool
< :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> Bool
$c<= :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> Bool
<= :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> Bool
$c> :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> Bool
> :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> Bool
$c>= :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> Bool
>= :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> Bool
$cmax :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> JannoGeneticSourceAccessionID
max :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> JannoGeneticSourceAccessionID
$cmin :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> JannoGeneticSourceAccessionID
min :: JannoGeneticSourceAccessionID
-> JannoGeneticSourceAccessionID -> JannoGeneticSourceAccessionID
Ord, (forall x.
 JannoGeneticSourceAccessionID
 -> Rep JannoGeneticSourceAccessionID x)
-> (forall x.
    Rep JannoGeneticSourceAccessionID x
    -> JannoGeneticSourceAccessionID)
-> Generic JannoGeneticSourceAccessionID
forall x.
Rep JannoGeneticSourceAccessionID x
-> JannoGeneticSourceAccessionID
forall x.
JannoGeneticSourceAccessionID
-> Rep JannoGeneticSourceAccessionID x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
JannoGeneticSourceAccessionID
-> Rep JannoGeneticSourceAccessionID x
from :: forall x.
JannoGeneticSourceAccessionID
-> Rep JannoGeneticSourceAccessionID x
$cto :: forall x.
Rep JannoGeneticSourceAccessionID x
-> JannoGeneticSourceAccessionID
to :: forall x.
Rep JannoGeneticSourceAccessionID x
-> JannoGeneticSourceAccessionID
Generic)

instance Makeable JannoGeneticSourceAccessionID where
    make :: forall (m :: * -> *).
MonadFail m =>
PoseidonVersion -> Text -> m JannoGeneticSourceAccessionID
make PoseidonVersion
_ Text
x = AccessionID -> JannoGeneticSourceAccessionID
JannoGeneticSourceAccessionID (AccessionID -> JannoGeneticSourceAccessionID)
-> m AccessionID -> m JannoGeneticSourceAccessionID
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> m AccessionID
forall (m :: * -> *). MonadFail m => Text -> m AccessionID
makeAccessionID Text
x
instance Suspicious JannoGeneticSourceAccessionID where inspect :: JannoGeneticSourceAccessionID -> Maybe [[Char]]
inspect JannoGeneticSourceAccessionID
_ = Maybe [[Char]]
forall a. Maybe a
Nothing
instance Show JannoGeneticSourceAccessionID where
    show :: JannoGeneticSourceAccessionID -> [Char]
show (JannoGeneticSourceAccessionID AccessionID
x) = AccessionID -> [Char]
forall a. Show a => a -> [Char]
show AccessionID
x
instance Csv.ToField JannoGeneticSourceAccessionID where   toField :: JannoGeneticSourceAccessionID -> Field
toField JannoGeneticSourceAccessionID
x  = [Char] -> Field
forall a. ToField a => a -> Field
Csv.toField ([Char] -> Field) -> [Char] -> Field
forall a b. (a -> b) -> a -> b
$ JannoGeneticSourceAccessionID -> [Char]
forall a. Show a => a -> [Char]
show JannoGeneticSourceAccessionID
x
instance FromFieldVersioned JannoGeneticSourceAccessionID where parseFieldVersioned :: PoseidonVersion -> Field -> Parser JannoGeneticSourceAccessionID
parseFieldVersioned PoseidonVersion
pv = PoseidonVersion
-> [Char] -> Field -> Parser JannoGeneticSourceAccessionID
forall a (m :: * -> *).
(MonadFail m, Makeable a, Typeable a) =>
PoseidonVersion -> [Char] -> Field -> m a
parseTypeCSV PoseidonVersion
pv [Char]
"Genetic_Source_Accession_IDs"

-- | A datatype for the Primary_Contact .janno column
newtype JannoPrimaryContact = JannoPrimaryContact T.Text deriving (JannoPrimaryContact -> JannoPrimaryContact -> Bool
(JannoPrimaryContact -> JannoPrimaryContact -> Bool)
-> (JannoPrimaryContact -> JannoPrimaryContact -> Bool)
-> Eq JannoPrimaryContact
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoPrimaryContact -> JannoPrimaryContact -> Bool
== :: JannoPrimaryContact -> JannoPrimaryContact -> Bool
$c/= :: JannoPrimaryContact -> JannoPrimaryContact -> Bool
/= :: JannoPrimaryContact -> JannoPrimaryContact -> Bool
Eq)
$(makeInstances ''JannoPrimaryContact "Primary_Contact")

-- | A datatype for the Publication .janno column
newtype JannoPublication = JannoPublication T.Text deriving (JannoPublication -> JannoPublication -> Bool
(JannoPublication -> JannoPublication -> Bool)
-> (JannoPublication -> JannoPublication -> Bool)
-> Eq JannoPublication
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoPublication -> JannoPublication -> Bool
== :: JannoPublication -> JannoPublication -> Bool
$c/= :: JannoPublication -> JannoPublication -> Bool
/= :: JannoPublication -> JannoPublication -> Bool
Eq, Eq JannoPublication
Eq JannoPublication =>
(JannoPublication -> JannoPublication -> Ordering)
-> (JannoPublication -> JannoPublication -> Bool)
-> (JannoPublication -> JannoPublication -> Bool)
-> (JannoPublication -> JannoPublication -> Bool)
-> (JannoPublication -> JannoPublication -> Bool)
-> (JannoPublication -> JannoPublication -> JannoPublication)
-> (JannoPublication -> JannoPublication -> JannoPublication)
-> Ord JannoPublication
JannoPublication -> JannoPublication -> Bool
JannoPublication -> JannoPublication -> Ordering
JannoPublication -> JannoPublication -> JannoPublication
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
$ccompare :: JannoPublication -> JannoPublication -> Ordering
compare :: JannoPublication -> JannoPublication -> Ordering
$c< :: JannoPublication -> JannoPublication -> Bool
< :: JannoPublication -> JannoPublication -> Bool
$c<= :: JannoPublication -> JannoPublication -> Bool
<= :: JannoPublication -> JannoPublication -> Bool
$c> :: JannoPublication -> JannoPublication -> Bool
> :: JannoPublication -> JannoPublication -> Bool
$c>= :: JannoPublication -> JannoPublication -> Bool
>= :: JannoPublication -> JannoPublication -> Bool
$cmax :: JannoPublication -> JannoPublication -> JannoPublication
max :: JannoPublication -> JannoPublication -> JannoPublication
$cmin :: JannoPublication -> JannoPublication -> JannoPublication
min :: JannoPublication -> JannoPublication -> JannoPublication
Ord)
$(makeInstances ''JannoPublication "Publication")

-- | A datatype for the Note .janno column
newtype JannoComment = JannoComment T.Text deriving (JannoComment -> JannoComment -> Bool
(JannoComment -> JannoComment -> Bool)
-> (JannoComment -> JannoComment -> Bool) -> Eq JannoComment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoComment -> JannoComment -> Bool
== :: JannoComment -> JannoComment -> Bool
$c/= :: JannoComment -> JannoComment -> Bool
/= :: JannoComment -> JannoComment -> Bool
Eq)
$(makeInstances ''JannoComment "Note")

-- | A datatype for the Keywords .janno column
newtype JannoKeyword = JannoKeyword T.Text deriving (JannoKeyword -> JannoKeyword -> Bool
(JannoKeyword -> JannoKeyword -> Bool)
-> (JannoKeyword -> JannoKeyword -> Bool) -> Eq JannoKeyword
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoKeyword -> JannoKeyword -> Bool
== :: JannoKeyword -> JannoKeyword -> Bool
$c/= :: JannoKeyword -> JannoKeyword -> Bool
/= :: JannoKeyword -> JannoKeyword -> Bool
Eq)
$(makeInstances ''JannoKeyword "Keywords")