{-# LANGUAGE DeriveGeneric       #-}
{-# LANGUAGE FlexibleInstances   #-}
{-# LANGUAGE OverloadedStrings   #-}
{-# LANGUAGE ScopedTypeVariables #-}
-- the following three are necessary for deriveGeneric
{-# LANGUAGE DataKinds           #-}
{-# LANGUAGE TemplateHaskell     #-}
{-# LANGUAGE TypeFamilies        #-}

module Poseidon.Janno (
    JannoRow(..),
    JannoSex (..),
    JannoList (..),
    Sex (..),
    BCADAge (..),
    JannoCountry (..),
    makeJannoCountryUnsafe,
    Latitude (..),
    Longitude (..),
    JannoDateType (..),
    JannoCaptureType (..),
    JannoGenotypePloidy (..),
    Percent (..),
    JannoUDG (..),
    JURI (..),
    RelationDegree (..),
    JannoLibraryBuilt (..),
    AccessionID (..),
    makeAccessionID,
    makeLatitude, makeLongitude,
    writeJannoFile,
    readJannoFile,
    createMinimalJanno,
    createMinimalSample,
    jannoHeaderString,
    CsvNamedRecord (..),
    JannoRows (..),
    JannoStringList,
    filterLookup,
    filterLookupOptional,
    getCsvNR,
    encodingOptions,
    decodingOptions,
    explicitNA,
    removeUselessSuffix,
    parseCsvParseError,
    renderCsvParseError,
    getMaybeJannoList
) where

import           Poseidon.Utils                       (PoseidonException (..),
                                                       PoseidonIO, logDebug,
                                                       logError, logWarning,
                                                       renderPoseidonException)


import           Control.Applicative                  (empty)
import           Control.Exception                    (throwIO)
import           Control.Monad                        (unless, when)
import qualified Control.Monad.Except                 as E
import           Control.Monad.IO.Class               (liftIO)
import qualified Control.Monad.Writer                 as W
import           Country                              (Country, alphaTwoUpper,
                                                       decodeAlphaTwo)
import           Data.Aeson                           (FromJSON, Options (..),
                                                       ToJSON, Value (..),
                                                       defaultOptions,
                                                       genericToEncoding,
                                                       parseJSON, toEncoding,
                                                       toJSON, withText)
import           Data.Aeson.Types                     (emptyObject)
import           Data.Bifunctor                       (second)
import qualified Data.ByteString.Char8                as Bchs
import qualified Data.ByteString.Lazy.Char8           as Bch
import           Data.Char                            (chr, isSpace, ord)
import qualified Data.Csv                             as Csv
import           Data.Either                          (lefts, rights)
import qualified Data.HashMap.Strict                  as HM
import           Data.List                            (elemIndex, foldl',
                                                       intercalate, nub, sort,
                                                       (\\))
import           Data.Maybe                           (fromJust)
import           Data.Text                            (pack, replace, unpack)
import qualified Data.Text                            as T
import qualified Data.Text.Encoding                   as T
import qualified Data.Vector                          as V
import           Generics.SOP.TH                      (deriveGeneric)
import           GHC.Generics                         (Generic)
import           Network.URI                          (isURIReference)
import           Options.Applicative.Help.Levenshtein (editDistance)
import           SequenceFormats.Eigenstrat           (EigenstratIndEntry (..),
                                                       Sex (..))
import qualified Text.Parsec                          as P
import qualified Text.Parsec.String                   as P
import qualified Text.Regex.TDFA                      as Reg

-- | A datatype for genetic sex
newtype JannoSex = JannoSex { JannoSex -> Sex
sfSex :: Sex }
    deriving (JannoSex -> JannoSex -> Bool
(JannoSex -> JannoSex -> Bool)
-> (JannoSex -> JannoSex -> Bool) -> Eq JannoSex
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoSex -> JannoSex -> Bool
== :: JannoSex -> JannoSex -> Bool
$c/= :: JannoSex -> JannoSex -> Bool
/= :: JannoSex -> JannoSex -> Bool
Eq)

instance Show JannoSex where
    show :: JannoSex -> String
show (JannoSex Sex
Female)  = String
"F"
    show (JannoSex Sex
Male)    = String
"M"
    show (JannoSex Sex
Unknown) = String
"U"

instance Ord JannoSex where
    compare :: JannoSex -> JannoSex -> Ordering
compare (JannoSex Sex
Female) (JannoSex Sex
Male)    = Ordering
GT
    compare (JannoSex Sex
Male) (JannoSex Sex
Female)    = Ordering
LT
    compare (JannoSex Sex
Male) (JannoSex Sex
Unknown)   = Ordering
GT
    compare (JannoSex Sex
Unknown) (JannoSex Sex
Male)   = Ordering
LT
    compare (JannoSex Sex
Female) (JannoSex Sex
Unknown) = Ordering
GT
    compare (JannoSex Sex
Unknown) (JannoSex Sex
Female) = Ordering
LT
    compare JannoSex
_ JannoSex
_                                  = Ordering
EQ

makeJannoSex :: MonadFail m => String -> m JannoSex
makeJannoSex :: forall (m :: * -> *). MonadFail m => String -> m JannoSex
makeJannoSex String
x
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"F"  = JannoSex -> m JannoSex
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Sex -> JannoSex
JannoSex Sex
Female)
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"M"  = JannoSex -> m JannoSex
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Sex -> JannoSex
JannoSex Sex
Male)
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"U"  = JannoSex -> m JannoSex
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Sex -> JannoSex
JannoSex Sex
Unknown)
    | Bool
otherwise = String -> m JannoSex
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m JannoSex) -> String -> m JannoSex
forall a b. (a -> b) -> a -> b
$ String
"Sex " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show String
x String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" not in [F, M, U]"

instance Csv.ToField JannoSex where
    toField :: JannoSex -> ByteString
toField JannoSex
x = String -> ByteString
forall a. ToField a => a -> ByteString
Csv.toField (String -> ByteString) -> String -> ByteString
forall a b. (a -> b) -> a -> b
$ JannoSex -> String
forall a. Show a => a -> String
show JannoSex
x
instance Csv.FromField JannoSex where
    parseField :: ByteString -> Parser JannoSex
parseField ByteString
x = ByteString -> Parser String
forall a. FromField a => ByteString -> Parser a
Csv.parseField ByteString
x Parser String -> (String -> Parser JannoSex) -> Parser JannoSex
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Parser JannoSex
forall (m :: * -> *). MonadFail m => String -> m JannoSex
makeJannoSex
instance ToJSON JannoSex where
    toJSON :: JannoSex -> Value
toJSON JannoSex
x  = Text -> Value
String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ JannoSex -> String
forall a. Show a => a -> String
show JannoSex
x
instance FromJSON JannoSex where
    parseJSON :: Value -> Parser JannoSex
parseJSON = String -> (Text -> Parser JannoSex) -> Value -> Parser JannoSex
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"JannoSex" (String -> Parser JannoSex
forall (m :: * -> *). MonadFail m => String -> m JannoSex
makeJannoSex (String -> Parser JannoSex)
-> (Text -> String) -> Text -> Parser JannoSex
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack)

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

instance Show BCADAge where
    show :: BCADAge -> String
show (BCADAge Int
x) = Int -> String
forall a. Show a => a -> String
show Int
x

makeBCADAge :: MonadFail m => Int -> m BCADAge
makeBCADAge :: forall (m :: * -> *). MonadFail m => Int -> m BCADAge
makeBCADAge Int
x =
    let curYear :: Int
curYear = Int
2023 -- the current year
    in if Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
curYear
       then String -> m BCADAge
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m BCADAge) -> String -> m BCADAge
forall a b. (a -> b) -> a -> b
$ String
"Age " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
x String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" later than " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
curYear String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
", which is impossible. " String -> ShowS
forall a. [a] -> [a] -> [a]
++
                   String
"Did you accidentally enter a BP date?"
      else BCADAge -> m BCADAge
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> BCADAge
BCADAge Int
x)

instance Csv.ToField BCADAge where
    toField :: BCADAge -> ByteString
toField (BCADAge Int
x) = Int -> ByteString
forall a. ToField a => a -> ByteString
Csv.toField Int
x
instance Csv.FromField BCADAge where
    parseField :: ByteString -> Parser BCADAge
parseField ByteString
x = ByteString -> Parser Int
forall a. FromField a => ByteString -> Parser a
Csv.parseField ByteString
x Parser Int -> (Int -> Parser BCADAge) -> Parser BCADAge
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> Parser BCADAge
forall (m :: * -> *). MonadFail m => Int -> m BCADAge
makeBCADAge
instance ToJSON BCADAge where
    toEncoding :: BCADAge -> Encoding
toEncoding = Options -> BCADAge -> Encoding
forall a.
(Generic a, GToJSON' Encoding Zero (Rep a)) =>
Options -> a -> Encoding
genericToEncoding Options
defaultOptions
instance FromJSON BCADAge-- where
    --parseJSON = withScientific "BCADAge" $ \n ->
    --    case toBoundedInteger n of
    --        Nothing -> fail $ "Number" ++ show n ++ "doesn't fit into a bounded integer."
    --        Just x -> makeBCADAge x

-- |A datatype to represent Date_Type in a janno file
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 Show JannoDateType where
    show :: JannoDateType -> String
show JannoDateType
C14        = String
"C14"
    show JannoDateType
Contextual = String
"contextual"
    show JannoDateType
Modern     = String
"modern"

makeJannoDateType :: MonadFail m => String -> m JannoDateType
makeJannoDateType :: forall (m :: * -> *). MonadFail m => String -> m JannoDateType
makeJannoDateType String
x
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"C14"        = JannoDateType -> m JannoDateType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoDateType
C14
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"contextual" = JannoDateType -> m JannoDateType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoDateType
Contextual
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"modern"     = JannoDateType -> m JannoDateType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoDateType
Modern
    | Bool
otherwise         = String -> m JannoDateType
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m JannoDateType) -> String -> m JannoDateType
forall a b. (a -> b) -> a -> b
$ String
"Date_Type " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show String
x String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" not in [C14, contextual, modern]"

instance Csv.ToField JannoDateType where
    toField :: JannoDateType -> ByteString
toField JannoDateType
x = String -> ByteString
forall a. ToField a => a -> ByteString
Csv.toField (String -> ByteString) -> String -> ByteString
forall a b. (a -> b) -> a -> b
$ JannoDateType -> String
forall a. Show a => a -> String
show JannoDateType
x
instance Csv.FromField JannoDateType where
    parseField :: ByteString -> Parser JannoDateType
parseField ByteString
x = ByteString -> Parser String
forall a. FromField a => ByteString -> Parser a
Csv.parseField ByteString
x Parser String
-> (String -> Parser JannoDateType) -> Parser JannoDateType
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Parser JannoDateType
forall (m :: * -> *). MonadFail m => String -> m JannoDateType
makeJannoDateType
instance ToJSON JannoDateType where
    toEncoding :: JannoDateType -> Encoding
toEncoding = Options -> JannoDateType -> Encoding
forall a.
(Generic a, GToJSON' Encoding Zero (Rep a)) =>
Options -> a -> Encoding
genericToEncoding Options
defaultOptions
    --toEncoding x = text $ T.pack $ show x
instance FromJSON JannoDateType-- where
    --parseJSON = withText "JannoDateType" (makeJannoDateType . T.unpack)

-- |A datatype to represent Capture_Type in a janno file
data JannoCaptureType =
      Shotgun
    | A1240K
    | ArborComplete
    | ArborPrimePlus
    | ArborAncestralPlus
    | TwistAncientDNA
    | OtherCapture
    | ReferenceGenome
    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 Show JannoCaptureType where
    show :: JannoCaptureType -> String
show JannoCaptureType
Shotgun            = String
"Shotgun"
    show JannoCaptureType
A1240K             = String
"1240K"
    show JannoCaptureType
ArborComplete      = String
"ArborComplete"
    show JannoCaptureType
ArborPrimePlus     = String
"ArborPrimePlus"
    show JannoCaptureType
ArborAncestralPlus = String
"ArborAncestralPlus"
    show JannoCaptureType
TwistAncientDNA    = String
"TwistAncientDNA"
    show JannoCaptureType
OtherCapture       = String
"OtherCapture"
    show JannoCaptureType
ReferenceGenome    = String
"ReferenceGenome"

makeJannoCaptureType :: MonadFail m => String -> m JannoCaptureType
makeJannoCaptureType :: forall (m :: * -> *). MonadFail m => String -> m JannoCaptureType
makeJannoCaptureType String
x
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"Shotgun"            = JannoCaptureType -> m JannoCaptureType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoCaptureType
Shotgun
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"1240K"              = JannoCaptureType -> m JannoCaptureType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoCaptureType
A1240K
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"ArborComplete"      = JannoCaptureType -> m JannoCaptureType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoCaptureType
ArborComplete
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"ArborPrimePlus"     = JannoCaptureType -> m JannoCaptureType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoCaptureType
ArborPrimePlus
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"ArborAncestralPlus" = JannoCaptureType -> m JannoCaptureType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoCaptureType
ArborAncestralPlus
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"TwistAncientDNA"    = JannoCaptureType -> m JannoCaptureType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoCaptureType
TwistAncientDNA
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"OtherCapture"       = JannoCaptureType -> m JannoCaptureType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoCaptureType
OtherCapture
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"ReferenceGenome"    = JannoCaptureType -> m JannoCaptureType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoCaptureType
ReferenceGenome
    | Bool
otherwise                 = String -> m JannoCaptureType
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m JannoCaptureType) -> String -> m JannoCaptureType
forall a b. (a -> b) -> a -> b
$ String
"Capture_Type " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show String
x String -> ShowS
forall a. [a] -> [a] -> [a]
++
                                      String
" not in [Shotgun, 1240K, ArborComplete, ArborPrimePlus, ArborAncestralPlus, TwistAncientDNA, OtherCapture, ReferenceGenome]"

instance Csv.ToField JannoCaptureType where
    toField :: JannoCaptureType -> ByteString
toField JannoCaptureType
x = String -> ByteString
forall a. ToField a => a -> ByteString
Csv.toField (String -> ByteString) -> String -> ByteString
forall a b. (a -> b) -> a -> b
$ JannoCaptureType -> String
forall a. Show a => a -> String
show JannoCaptureType
x
instance Csv.FromField JannoCaptureType where
    parseField :: ByteString -> Parser JannoCaptureType
parseField ByteString
x = ByteString -> Parser String
forall a. FromField a => ByteString -> Parser a
Csv.parseField ByteString
x Parser String
-> (String -> Parser JannoCaptureType) -> Parser JannoCaptureType
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Parser JannoCaptureType
forall (m :: * -> *). MonadFail m => String -> m JannoCaptureType
makeJannoCaptureType
instance ToJSON JannoCaptureType where
    toEncoding :: JannoCaptureType -> Encoding
toEncoding = Options -> JannoCaptureType -> Encoding
forall a.
(Generic a, GToJSON' Encoding Zero (Rep a)) =>
Options -> a -> Encoding
genericToEncoding Options
defaultOptions
    --toEncoding x = text $ T.pack $ show x
instance FromJSON JannoCaptureType-- where
    --parseJSON = withText "JannoCaptureType" (makeJannoCaptureType . T.unpack)

-- |A datatype to represent Genotype_Ploidy in a janno file
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 Show JannoGenotypePloidy where
    show :: JannoGenotypePloidy -> String
show JannoGenotypePloidy
Diploid = String
"diploid"
    show JannoGenotypePloidy
Haploid = String
"haploid"

makeJannoGenotypePloidy :: MonadFail m => String -> m JannoGenotypePloidy
makeJannoGenotypePloidy :: forall (m :: * -> *).
MonadFail m =>
String -> m JannoGenotypePloidy
makeJannoGenotypePloidy String
x
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"diploid" = JannoGenotypePloidy -> m JannoGenotypePloidy
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoGenotypePloidy
Diploid
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"haploid" = JannoGenotypePloidy -> m JannoGenotypePloidy
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoGenotypePloidy
Haploid
    | Bool
otherwise      = String -> m JannoGenotypePloidy
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m JannoGenotypePloidy)
-> String -> m JannoGenotypePloidy
forall a b. (a -> b) -> a -> b
$ String
"Genotype_Ploidy " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show String
x String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" not in [diploid, haploid]"

instance Csv.ToField JannoGenotypePloidy where
    toField :: JannoGenotypePloidy -> ByteString
toField JannoGenotypePloidy
x = String -> ByteString
forall a. ToField a => a -> ByteString
Csv.toField (String -> ByteString) -> String -> ByteString
forall a b. (a -> b) -> a -> b
$ JannoGenotypePloidy -> String
forall a. Show a => a -> String
show JannoGenotypePloidy
x
instance Csv.FromField JannoGenotypePloidy where
    parseField :: ByteString -> Parser JannoGenotypePloidy
parseField ByteString
x = ByteString -> Parser String
forall a. FromField a => ByteString -> Parser a
Csv.parseField ByteString
x Parser String
-> (String -> Parser JannoGenotypePloidy)
-> Parser JannoGenotypePloidy
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Parser JannoGenotypePloidy
forall (m :: * -> *).
MonadFail m =>
String -> m JannoGenotypePloidy
makeJannoGenotypePloidy
instance ToJSON JannoGenotypePloidy where
    toEncoding :: JannoGenotypePloidy -> Encoding
toEncoding = Options -> JannoGenotypePloidy -> Encoding
forall a.
(Generic a, GToJSON' Encoding Zero (Rep a)) =>
Options -> a -> Encoding
genericToEncoding Options
defaultOptions
    --toEncoding x = text $ T.pack $ show x
instance FromJSON JannoGenotypePloidy-- where
    --parseJSON = withText "JannoGenotypePloidy" (makeJannoGenotypePloidy . T.unpack)

-- |A datatype to represent UDG in a janno file
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 Show JannoUDG where
    show :: JannoUDG -> String
show JannoUDG
Minus = String
"minus"
    show JannoUDG
Half  = String
"half"
    show JannoUDG
Plus  = String
"plus"
    show JannoUDG
Mixed = String
"mixed"

makeJannoUDG :: MonadFail m => String -> m JannoUDG
makeJannoUDG :: forall (m :: * -> *). MonadFail m => String -> m JannoUDG
makeJannoUDG String
x
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"minus" = JannoUDG -> m JannoUDG
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoUDG
Minus
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"half"  = JannoUDG -> m JannoUDG
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoUDG
Half
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"plus"  = JannoUDG -> m JannoUDG
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoUDG
Plus
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"mixed" = JannoUDG -> m JannoUDG
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoUDG
Mixed
    | Bool
otherwise    = String -> m JannoUDG
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m JannoUDG) -> String -> m JannoUDG
forall a b. (a -> b) -> a -> b
$ String
"UDG " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show String
x String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" not in [minus, half, plus, mixed]"

instance Csv.ToField JannoUDG where
    toField :: JannoUDG -> ByteString
toField JannoUDG
x = String -> ByteString
forall a. ToField a => a -> ByteString
Csv.toField (String -> ByteString) -> String -> ByteString
forall a b. (a -> b) -> a -> b
$ JannoUDG -> String
forall a. Show a => a -> String
show JannoUDG
x
instance Csv.FromField JannoUDG where
    parseField :: ByteString -> Parser JannoUDG
parseField ByteString
x = ByteString -> Parser String
forall a. FromField a => ByteString -> Parser a
Csv.parseField ByteString
x Parser String -> (String -> Parser JannoUDG) -> Parser JannoUDG
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Parser JannoUDG
forall (m :: * -> *). MonadFail m => String -> m JannoUDG
makeJannoUDG
instance ToJSON JannoUDG where
    toEncoding :: JannoUDG -> Encoding
toEncoding = Options -> JannoUDG -> Encoding
forall a.
(Generic a, GToJSON' Encoding Zero (Rep a)) =>
Options -> a -> Encoding
genericToEncoding Options
defaultOptions
    --toEncoding x = text $ T.pack $ show x
instance FromJSON JannoUDG-- where
    --parseJSON = withText "JannoUDG" (makeJannoUDG . T.unpack)

-- |A datatype to represent Library_Built in a janno file
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 Show JannoLibraryBuilt where
    show :: JannoLibraryBuilt -> String
show JannoLibraryBuilt
DS        = String
"ds"
    show JannoLibraryBuilt
SS        = String
"ss"
    show JannoLibraryBuilt
MixedSSDS = String
"mixed"
    show JannoLibraryBuilt
Other     = String
"other"

makeJannoLibraryBuilt :: MonadFail m => String -> m JannoLibraryBuilt
makeJannoLibraryBuilt :: forall (m :: * -> *). MonadFail m => String -> m JannoLibraryBuilt
makeJannoLibraryBuilt String
x
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"ds"    = JannoLibraryBuilt -> m JannoLibraryBuilt
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoLibraryBuilt
DS
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"ss"    = JannoLibraryBuilt -> m JannoLibraryBuilt
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoLibraryBuilt
SS
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"mixed" = JannoLibraryBuilt -> m JannoLibraryBuilt
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoLibraryBuilt
MixedSSDS
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"other" = JannoLibraryBuilt -> m JannoLibraryBuilt
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JannoLibraryBuilt
Other
    | Bool
otherwise    = String -> m JannoLibraryBuilt
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m JannoLibraryBuilt) -> String -> m JannoLibraryBuilt
forall a b. (a -> b) -> a -> b
$ String
"Library_Built " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show String
x String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" not in [ds, ss, mixed]"

instance Csv.ToField JannoLibraryBuilt where
    toField :: JannoLibraryBuilt -> ByteString
toField JannoLibraryBuilt
x = String -> ByteString
forall a. ToField a => a -> ByteString
Csv.toField (String -> ByteString) -> String -> ByteString
forall a b. (a -> b) -> a -> b
$ JannoLibraryBuilt -> String
forall a. Show a => a -> String
show JannoLibraryBuilt
x
instance Csv.FromField JannoLibraryBuilt where
    parseField :: ByteString -> Parser JannoLibraryBuilt
parseField ByteString
x = ByteString -> Parser String
forall a. FromField a => ByteString -> Parser a
Csv.parseField ByteString
x Parser String
-> (String -> Parser JannoLibraryBuilt) -> Parser JannoLibraryBuilt
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Parser JannoLibraryBuilt
forall (m :: * -> *). MonadFail m => String -> m JannoLibraryBuilt
makeJannoLibraryBuilt
instance ToJSON JannoLibraryBuilt where
    toEncoding :: JannoLibraryBuilt -> Encoding
toEncoding = Options -> JannoLibraryBuilt -> Encoding
forall a.
(Generic a, GToJSON' Encoding Zero (Rep a)) =>
Options -> a -> Encoding
genericToEncoding Options
defaultOptions
    --toEncoding x = text $ T.pack $ show x
instance FromJSON JannoLibraryBuilt --where
    --parseJSON = withText "JannoLibraryBuilt" (makeJannoLibraryBuilt . T.unpack)

-- | A datatype for countries in ISO-alpha2 code format
newtype JannoCountry = JannoCountry Country
    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)

instance Show JannoCountry where
    show :: JannoCountry -> String
show (JannoCountry Country
x) = Text -> String
T.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ Country -> Text
alphaTwoUpper Country
x

makeJannoCountryEither :: String -> Either PoseidonException JannoCountry
makeJannoCountryEither :: String -> Either PoseidonException JannoCountry
makeJannoCountryEither String
x =
    case Text -> Maybe Country
decodeAlphaTwo (String -> Text
T.pack String
x) of
        Just Country
c  -> JannoCountry -> Either PoseidonException JannoCountry
forall a b. b -> Either a b
Right (JannoCountry -> Either PoseidonException JannoCountry)
-> JannoCountry -> Either PoseidonException JannoCountry
forall a b. (a -> b) -> a -> b
$ Country -> JannoCountry
JannoCountry Country
c
        Maybe Country
Nothing -> PoseidonException -> Either PoseidonException JannoCountry
forall a b. a -> Either a b
Left (PoseidonException -> Either PoseidonException JannoCountry)
-> (String -> PoseidonException)
-> String
-> Either PoseidonException JannoCountry
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> PoseidonException
PoseidonGenericException (String -> Either PoseidonException JannoCountry)
-> String -> Either PoseidonException JannoCountry
forall a b. (a -> b) -> a -> b
$ String
x String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" is not a valid ISO-alpha2 code describing an existing country"

makeJannoCountryUnsafe :: String -> JannoCountry
makeJannoCountryUnsafe :: String -> JannoCountry
makeJannoCountryUnsafe String
x = case String -> Either PoseidonException JannoCountry
makeJannoCountryEither String
x of
    Left PoseidonException
e  -> String -> JannoCountry
forall a. HasCallStack => String -> a
error (String -> JannoCountry)
-> (PoseidonException -> String)
-> PoseidonException
-> JannoCountry
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PoseidonException -> String
forall a. Show a => a -> String
show (PoseidonException -> JannoCountry)
-> PoseidonException -> JannoCountry
forall a b. (a -> b) -> a -> b
$ PoseidonException
e
    Right JannoCountry
r -> JannoCountry
r

makeJannoCountry :: (MonadFail m) => String -> m JannoCountry
makeJannoCountry :: forall (m :: * -> *). MonadFail m => String -> m JannoCountry
makeJannoCountry String
x = case String -> Either PoseidonException JannoCountry
makeJannoCountryEither String
x of
    Left PoseidonException
e  -> String -> m JannoCountry
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m JannoCountry)
-> (PoseidonException -> String)
-> PoseidonException
-> m JannoCountry
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PoseidonException -> String
forall a. Show a => a -> String
show (PoseidonException -> m JannoCountry)
-> PoseidonException -> m JannoCountry
forall a b. (a -> b) -> a -> b
$ PoseidonException
e
    Right JannoCountry
r -> JannoCountry -> m JannoCountry
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return JannoCountry
r

instance Csv.ToField JannoCountry where
    toField :: JannoCountry -> ByteString
toField JannoCountry
x = String -> ByteString
forall a. ToField a => a -> ByteString
Csv.toField (String -> ByteString) -> String -> ByteString
forall a b. (a -> b) -> a -> b
$ JannoCountry -> String
forall a. Show a => a -> String
show JannoCountry
x
instance Csv.FromField JannoCountry where
    parseField :: ByteString -> Parser JannoCountry
parseField ByteString
x = ByteString -> Parser String
forall a. FromField a => ByteString -> Parser a
Csv.parseField ByteString
x Parser String
-> (String -> Parser JannoCountry) -> Parser JannoCountry
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Parser JannoCountry
forall (m :: * -> *). MonadFail m => String -> m JannoCountry
makeJannoCountry
instance ToJSON JannoCountry where
    toJSON :: JannoCountry -> Value
toJSON JannoCountry
x  = Text -> Value
String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ JannoCountry -> String
forall a. Show a => a -> String
show JannoCountry
x
instance FromJSON JannoCountry where
    parseJSON :: Value -> Parser JannoCountry
parseJSON = String
-> (Text -> Parser JannoCountry) -> Value -> Parser JannoCountry
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"JannoCountry" (String -> Parser JannoCountry
forall (m :: * -> *). MonadFail m => String -> m JannoCountry
makeJannoCountry (String -> Parser JannoCountry)
-> (Text -> String) -> Text -> Parser JannoCountry
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack)

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

instance Show Latitude where
    show :: Latitude -> String
show (Latitude Double
x) = Double -> String
forall a. Show a => a -> String
show Double
x

makeLatitude :: MonadFail m => Double -> m Latitude
makeLatitude :: forall (m :: * -> *). MonadFail m => Double -> m Latitude
makeLatitude Double
x
    | Double
x Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= -Double
90 Bool -> Bool -> Bool
&& Double
x Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<= Double
90 = Latitude -> m Latitude
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> Latitude
Latitude Double
x)
    | Bool
otherwise           = String -> m Latitude
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m Latitude) -> String -> m Latitude
forall a b. (a -> b) -> a -> b
$ String
"Latitude " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Double -> String
forall a. Show a => a -> String
show Double
x String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" not between -90 and 90"

instance Csv.ToField Latitude where
    toField :: Latitude -> ByteString
toField (Latitude Double
x) = Double -> ByteString
forall a. ToField a => a -> ByteString
Csv.toField Double
x
instance Csv.FromField Latitude where
    parseField :: ByteString -> Parser Latitude
parseField ByteString
x = ByteString -> Parser Double
forall a. FromField a => ByteString -> Parser a
Csv.parseField ByteString
x Parser Double -> (Double -> Parser Latitude) -> Parser Latitude
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Double -> Parser Latitude
forall (m :: * -> *). MonadFail m => Double -> m Latitude
makeLatitude
instance ToJSON Latitude where
    toEncoding :: Latitude -> Encoding
toEncoding = Options -> Latitude -> Encoding
forall a.
(Generic a, GToJSON' Encoding Zero (Rep a)) =>
Options -> a -> Encoding
genericToEncoding Options
defaultOptions
instance FromJSON Latitude-- where
    --parseJSON = withScientific "Latitude" $ \n -> (makeLatitude . toRealFloat) n

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

instance Show Longitude where
    show :: Longitude -> String
show (Longitude Double
x) = Double -> String
forall a. Show a => a -> String
show Double
x

makeLongitude :: MonadFail m => Double -> m Longitude
makeLongitude :: forall (m :: * -> *). MonadFail m => Double -> m Longitude
makeLongitude Double
x
    | Double
x Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= -Double
180 Bool -> Bool -> Bool
&& Double
x Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<= Double
180 = Longitude -> m Longitude
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> Longitude
Longitude Double
x)
    | Bool
otherwise             = String -> m Longitude
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m Longitude) -> String -> m Longitude
forall a b. (a -> b) -> a -> b
$ String
"Longitude " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Double -> String
forall a. Show a => a -> String
show Double
x String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" not between -180 and 180"

instance Csv.ToField Longitude where
    toField :: Longitude -> ByteString
toField (Longitude Double
x) = Double -> ByteString
forall a. ToField a => a -> ByteString
Csv.toField Double
x
instance Csv.FromField Longitude where
    parseField :: ByteString -> Parser Longitude
parseField ByteString
x = ByteString -> Parser Double
forall a. FromField a => ByteString -> Parser a
Csv.parseField ByteString
x Parser Double -> (Double -> Parser Longitude) -> Parser Longitude
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Double -> Parser Longitude
forall (m :: * -> *). MonadFail m => Double -> m Longitude
makeLongitude
instance ToJSON Longitude where
    toEncoding :: Longitude -> Encoding
toEncoding = Options -> Longitude -> Encoding
forall a.
(Generic a, GToJSON' Encoding Zero (Rep a)) =>
Options -> a -> Encoding
genericToEncoding Options
defaultOptions
instance FromJSON Longitude-- where
    --parseJSON = withScientific "Longitude" $ \n -> (makeLongitude . toRealFloat) n

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

instance Show Percent where
    show :: Percent -> String
show (Percent Double
x) = Double -> String
forall a. Show a => a -> String
show Double
x

makePercent :: MonadFail m => Double -> m Percent
makePercent :: forall (m :: * -> *). MonadFail m => Double -> m Percent
makePercent Double
x
    | Double
x Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= Double
0 Bool -> Bool -> Bool
&& Double
x Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<= Double
100 = Percent -> m Percent
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> Percent
Percent Double
x)
    | Bool
otherwise          = String -> m Percent
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m Percent) -> String -> m Percent
forall a b. (a -> b) -> a -> b
$ String
"Percentage " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Double -> String
forall a. Show a => a -> String
show Double
x String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" not between 0 and 100"

instance Csv.ToField Percent where
    toField :: Percent -> ByteString
toField (Percent Double
x) = Double -> ByteString
forall a. ToField a => a -> ByteString
Csv.toField Double
x
instance Csv.FromField Percent where
    parseField :: ByteString -> Parser Percent
parseField ByteString
x = ByteString -> Parser Double
forall a. FromField a => ByteString -> Parser a
Csv.parseField ByteString
x Parser Double -> (Double -> Parser Percent) -> Parser Percent
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Double -> Parser Percent
forall (m :: * -> *). MonadFail m => Double -> m Percent
makePercent
instance ToJSON Percent where
    toEncoding :: Percent -> Encoding
toEncoding = Options -> Percent -> Encoding
forall a.
(Generic a, GToJSON' Encoding Zero (Rep a)) =>
Options -> a -> Encoding
genericToEncoding Options
defaultOptions
instance FromJSON Percent-- where
    --parseJSON = withScientific "Percent" $ \n -> (makePercent . toRealFloat) n

-- | A datatype to represent URIs in a janno file
newtype JURI =
        JURI String
    deriving (JURI -> JURI -> Bool
(JURI -> JURI -> Bool) -> (JURI -> JURI -> Bool) -> Eq JURI
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JURI -> JURI -> Bool
== :: JURI -> JURI -> Bool
$c/= :: JURI -> JURI -> Bool
/= :: JURI -> JURI -> Bool
Eq, Eq JURI
Eq JURI
-> (JURI -> JURI -> Ordering)
-> (JURI -> JURI -> Bool)
-> (JURI -> JURI -> Bool)
-> (JURI -> JURI -> Bool)
-> (JURI -> JURI -> Bool)
-> (JURI -> JURI -> JURI)
-> (JURI -> JURI -> JURI)
-> Ord JURI
JURI -> JURI -> Bool
JURI -> JURI -> Ordering
JURI -> JURI -> JURI
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 :: JURI -> JURI -> Ordering
compare :: JURI -> JURI -> Ordering
$c< :: JURI -> JURI -> Bool
< :: JURI -> JURI -> Bool
$c<= :: JURI -> JURI -> Bool
<= :: JURI -> JURI -> Bool
$c> :: JURI -> JURI -> Bool
> :: JURI -> JURI -> Bool
$c>= :: JURI -> JURI -> Bool
>= :: JURI -> JURI -> Bool
$cmax :: JURI -> JURI -> JURI
max :: JURI -> JURI -> JURI
$cmin :: JURI -> JURI -> JURI
min :: JURI -> JURI -> JURI
Ord, (forall x. JURI -> Rep JURI x)
-> (forall x. Rep JURI x -> JURI) -> Generic JURI
forall x. Rep JURI x -> JURI
forall x. JURI -> Rep JURI x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JURI -> Rep JURI x
from :: forall x. JURI -> Rep JURI x
$cto :: forall x. Rep JURI x -> JURI
to :: forall x. Rep JURI x -> JURI
Generic)

instance Show JURI where
    show :: JURI -> String
show (JURI String
x) = String
x

makeJURI :: MonadFail m => String -> m JURI
makeJURI :: forall (m :: * -> *). MonadFail m => String -> m JURI
makeJURI String
x
    | String -> Bool
isURIReference String
x   = JURI -> m JURI
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (JURI -> m JURI) -> JURI -> m JURI
forall a b. (a -> b) -> a -> b
$ String -> JURI
JURI String
x
    | Bool
otherwise          = String -> m JURI
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m JURI) -> String -> m JURI
forall a b. (a -> b) -> a -> b
$ String
"URI " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show String
x String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" not well structured"

instance Csv.ToField JURI where
    toField :: JURI -> ByteString
toField JURI
x = String -> ByteString
forall a. ToField a => a -> ByteString
Csv.toField (String -> ByteString) -> String -> ByteString
forall a b. (a -> b) -> a -> b
$ JURI -> String
forall a. Show a => a -> String
show JURI
x
instance Csv.FromField JURI where
    parseField :: ByteString -> Parser JURI
parseField ByteString
x = ByteString -> Parser String
forall a. FromField a => ByteString -> Parser a
Csv.parseField ByteString
x Parser String -> (String -> Parser JURI) -> Parser JURI
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Parser JURI
forall (m :: * -> *). MonadFail m => String -> m JURI
makeJURI
instance ToJSON JURI where
    toEncoding :: JURI -> Encoding
toEncoding = Options -> JURI -> Encoding
forall a.
(Generic a, GToJSON' Encoding Zero (Rep a)) =>
Options -> a -> Encoding
genericToEncoding Options
defaultOptions
    --toEncoding x = text $ T.pack $ show x
instance FromJSON JURI-- where
    --parseJSON = withText "JURI" (makeJURI . T.unpack)

-- |A datatype to represent Relationship degree lists in a janno file
type JannoRelationDegreeList = JannoList RelationDegree

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

instance Show RelationDegree where
    show :: RelationDegree -> String
show RelationDegree
Identical    = String
"identical"
    show RelationDegree
First        = String
"first"
    show RelationDegree
Second       = String
"second"
    show RelationDegree
ThirdToFifth = String
"thirdToFifth"
    show RelationDegree
SixthToTenth = String
"sixthToTenth"
    show RelationDegree
Unrelated    = String
"unrelated"
    show RelationDegree
OtherDegree  = String
"other"

makeRelationDegree :: MonadFail m => String -> m RelationDegree
makeRelationDegree :: forall (m :: * -> *). MonadFail m => String -> m RelationDegree
makeRelationDegree String
x
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"identical"    = RelationDegree -> m RelationDegree
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure RelationDegree
Identical
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"first"        = RelationDegree -> m RelationDegree
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure RelationDegree
First
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"second"       = RelationDegree -> m RelationDegree
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure RelationDegree
Second
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"thirdToFifth" = RelationDegree -> m RelationDegree
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure RelationDegree
ThirdToFifth
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"sixthToTenth" = RelationDegree -> m RelationDegree
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure RelationDegree
SixthToTenth
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"unrelated"    = RelationDegree -> m RelationDegree
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure RelationDegree
Unrelated -- this should be omitted in the documentation
                                           -- relations of type "unrelated" don't have to be
                                           -- listed explicitly
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"other"        = RelationDegree -> m RelationDegree
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure RelationDegree
OtherDegree
    | Bool
otherwise           = String -> m RelationDegree
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m RelationDegree) -> String -> m RelationDegree
forall a b. (a -> b) -> a -> b
$ String
"Relation degree " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show String
x String -> ShowS
forall a. [a] -> [a] -> [a]
++
                                   String
" not in [identical, first, second, thirdToFifth, sixthToTenth, other]"

instance Csv.ToField RelationDegree where
    toField :: RelationDegree -> ByteString
toField RelationDegree
x = String -> ByteString
forall a. ToField a => a -> ByteString
Csv.toField (String -> ByteString) -> String -> ByteString
forall a b. (a -> b) -> a -> b
$ RelationDegree -> String
forall a. Show a => a -> String
show RelationDegree
x
instance Csv.FromField RelationDegree where
    parseField :: ByteString -> Parser RelationDegree
parseField ByteString
x = ByteString -> Parser String
forall a. FromField a => ByteString -> Parser a
Csv.parseField ByteString
x Parser String
-> (String -> Parser RelationDegree) -> Parser RelationDegree
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Parser RelationDegree
forall (m :: * -> *). MonadFail m => String -> m RelationDegree
makeRelationDegree
instance ToJSON RelationDegree where
    toEncoding :: RelationDegree -> Encoding
toEncoding = Options -> RelationDegree -> Encoding
forall a.
(Generic a, GToJSON' Encoding Zero (Rep a)) =>
Options -> a -> Encoding
genericToEncoding Options
defaultOptions
    --toEncoding x = text $ T.pack $ show x
instance FromJSON RelationDegree-- where
    --parseJSON = withText "RelationDegree" (makeRelationDegree . T.unpack)

-- |A datatype to represent AccessionIDs in a janno file
data AccessionID =
      INSDCProject String
    | INSDCStudy String
    | INSDCBioSample String
    | INSDCSample String
    | INSDCExperiment String
    | INSDCRun String
    | INSDCAnalysis String
    | OtherID String
    deriving (AccessionID -> AccessionID -> Bool
(AccessionID -> AccessionID -> Bool)
-> (AccessionID -> AccessionID -> Bool) -> Eq AccessionID
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AccessionID -> AccessionID -> Bool
== :: AccessionID -> AccessionID -> Bool
$c/= :: AccessionID -> AccessionID -> Bool
/= :: AccessionID -> AccessionID -> Bool
Eq, Eq AccessionID
Eq AccessionID
-> (AccessionID -> AccessionID -> Ordering)
-> (AccessionID -> AccessionID -> Bool)
-> (AccessionID -> AccessionID -> Bool)
-> (AccessionID -> AccessionID -> Bool)
-> (AccessionID -> AccessionID -> Bool)
-> (AccessionID -> AccessionID -> AccessionID)
-> (AccessionID -> AccessionID -> AccessionID)
-> Ord AccessionID
AccessionID -> AccessionID -> Bool
AccessionID -> AccessionID -> Ordering
AccessionID -> AccessionID -> AccessionID
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 :: AccessionID -> AccessionID -> Ordering
compare :: AccessionID -> AccessionID -> Ordering
$c< :: AccessionID -> AccessionID -> Bool
< :: AccessionID -> AccessionID -> Bool
$c<= :: AccessionID -> AccessionID -> Bool
<= :: AccessionID -> AccessionID -> Bool
$c> :: AccessionID -> AccessionID -> Bool
> :: AccessionID -> AccessionID -> Bool
$c>= :: AccessionID -> AccessionID -> Bool
>= :: AccessionID -> AccessionID -> Bool
$cmax :: AccessionID -> AccessionID -> AccessionID
max :: AccessionID -> AccessionID -> AccessionID
$cmin :: AccessionID -> AccessionID -> AccessionID
min :: AccessionID -> AccessionID -> AccessionID
Ord, (forall x. AccessionID -> Rep AccessionID x)
-> (forall x. Rep AccessionID x -> AccessionID)
-> Generic AccessionID
forall x. Rep AccessionID x -> AccessionID
forall x. AccessionID -> Rep AccessionID x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AccessionID -> Rep AccessionID x
from :: forall x. AccessionID -> Rep AccessionID x
$cto :: forall x. Rep AccessionID x -> AccessionID
to :: forall x. Rep AccessionID x -> AccessionID
Generic)

instance Show AccessionID where
    show :: AccessionID -> String
show (INSDCProject String
x)    = String
x
    show (INSDCStudy String
x)      = String
x
    show (INSDCBioSample String
x)  = String
x
    show (INSDCSample String
x)     = String
x
    show (INSDCExperiment String
x) = String
x
    show (INSDCRun String
x)        = String
x
    show (INSDCAnalysis String
x)   = String
x
    show (OtherID String
x)         = String
x

-- the patterns are documented at:
-- https://ena-docs.readthedocs.io/en/latest/submit/general-guide/accessions.html
makeAccessionID :: MonadFail m => String -> m AccessionID
makeAccessionID :: forall (m :: * -> *). MonadFail m => String -> m AccessionID
makeAccessionID String
x
    | String
x String -> String -> Bool
forall source source1 target.
(RegexMaker Regex CompOption ExecOption source,
 RegexContext Regex source1 target) =>
source1 -> source -> target
Reg.=~ (String
"PRJ[EDN][A-Z][0-9]+"  :: String) = AccessionID -> m AccessionID
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (AccessionID -> m AccessionID) -> AccessionID -> m AccessionID
forall a b. (a -> b) -> a -> b
$ String -> AccessionID
INSDCProject String
x
    | String
x String -> String -> Bool
forall source source1 target.
(RegexMaker Regex CompOption ExecOption source,
 RegexContext Regex source1 target) =>
source1 -> source -> target
Reg.=~ (String
"[EDS]RP[0-9]{6,}"     :: String) = AccessionID -> m AccessionID
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (AccessionID -> m AccessionID) -> AccessionID -> m AccessionID
forall a b. (a -> b) -> a -> b
$ String -> AccessionID
INSDCStudy String
x
    | String
x String -> String -> Bool
forall source source1 target.
(RegexMaker Regex CompOption ExecOption source,
 RegexContext Regex source1 target) =>
source1 -> source -> target
Reg.=~ (String
"SAM[EDN][A-Z]?[0-9]+" :: String) = AccessionID -> m AccessionID
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (AccessionID -> m AccessionID) -> AccessionID -> m AccessionID
forall a b. (a -> b) -> a -> b
$ String -> AccessionID
INSDCBioSample String
x
    | String
x String -> String -> Bool
forall source source1 target.
(RegexMaker Regex CompOption ExecOption source,
 RegexContext Regex source1 target) =>
source1 -> source -> target
Reg.=~ (String
"[EDS]RS[0-9]{6,}"     :: String) = AccessionID -> m AccessionID
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (AccessionID -> m AccessionID) -> AccessionID -> m AccessionID
forall a b. (a -> b) -> a -> b
$ String -> AccessionID
INSDCSample String
x
    | String
x String -> String -> Bool
forall source source1 target.
(RegexMaker Regex CompOption ExecOption source,
 RegexContext Regex source1 target) =>
source1 -> source -> target
Reg.=~ (String
"[EDS]RX[0-9]{6,}"     :: String) = AccessionID -> m AccessionID
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (AccessionID -> m AccessionID) -> AccessionID -> m AccessionID
forall a b. (a -> b) -> a -> b
$ String -> AccessionID
INSDCExperiment String
x
    | String
x String -> String -> Bool
forall source source1 target.
(RegexMaker Regex CompOption ExecOption source,
 RegexContext Regex source1 target) =>
source1 -> source -> target
Reg.=~ (String
"[EDS]RR[0-9]{6,}"     :: String) = AccessionID -> m AccessionID
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (AccessionID -> m AccessionID) -> AccessionID -> m AccessionID
forall a b. (a -> b) -> a -> b
$ String -> AccessionID
INSDCRun String
x
    | String
x String -> String -> Bool
forall source source1 target.
(RegexMaker Regex CompOption ExecOption source,
 RegexContext Regex source1 target) =>
source1 -> source -> target
Reg.=~ (String
"[EDS]RZ[0-9]{6,}"     :: String) = AccessionID -> m AccessionID
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (AccessionID -> m AccessionID) -> AccessionID -> m AccessionID
forall a b. (a -> b) -> a -> b
$ String -> AccessionID
INSDCAnalysis String
x
    | Bool
otherwise                                   = AccessionID -> m AccessionID
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (AccessionID -> m AccessionID) -> AccessionID -> m AccessionID
forall a b. (a -> b) -> a -> b
$ String -> AccessionID
OtherID String
x

instance Csv.ToField AccessionID where
    toField :: AccessionID -> ByteString
toField AccessionID
x = String -> ByteString
forall a. ToField a => a -> ByteString
Csv.toField (String -> ByteString) -> String -> ByteString
forall a b. (a -> b) -> a -> b
$ AccessionID -> String
forall a. Show a => a -> String
show AccessionID
x
instance Csv.FromField AccessionID where
    parseField :: ByteString -> Parser AccessionID
parseField ByteString
x = ByteString -> Parser String
forall a. FromField a => ByteString -> Parser a
Csv.parseField ByteString
x Parser String
-> (String -> Parser AccessionID) -> Parser AccessionID
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Parser AccessionID
forall (m :: * -> *). MonadFail m => String -> m AccessionID
makeAccessionID
instance ToJSON AccessionID where
    toEncoding :: AccessionID -> Encoding
toEncoding = Options -> AccessionID -> Encoding
forall a.
(Generic a, GToJSON' Encoding Zero (Rep a)) =>
Options -> a -> Encoding
genericToEncoding Options
defaultOptions
    --toEncoding x = text $ T.pack $ show x
instance FromJSON AccessionID-- where
    --parseJSON = withText "AccessionID" (makeAccessionID . T.unpack)

-- | A general datatype for janno list columns
newtype JannoList a = JannoList {forall a. JannoList a -> [a]
getJannoList :: [a]}
    deriving (JannoList a -> JannoList a -> Bool
(JannoList a -> JannoList a -> Bool)
-> (JannoList a -> JannoList a -> Bool) -> Eq (JannoList a)
forall a. Eq a => JannoList a -> JannoList a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => JannoList a -> JannoList a -> Bool
== :: JannoList a -> JannoList a -> Bool
$c/= :: forall a. Eq a => JannoList a -> JannoList a -> Bool
/= :: JannoList a -> JannoList a -> Bool
Eq, Eq (JannoList a)
Eq (JannoList a)
-> (JannoList a -> JannoList a -> Ordering)
-> (JannoList a -> JannoList a -> Bool)
-> (JannoList a -> JannoList a -> Bool)
-> (JannoList a -> JannoList a -> Bool)
-> (JannoList a -> JannoList a -> Bool)
-> (JannoList a -> JannoList a -> JannoList a)
-> (JannoList a -> JannoList a -> JannoList a)
-> Ord (JannoList a)
JannoList a -> JannoList a -> Bool
JannoList a -> JannoList a -> Ordering
JannoList a -> JannoList a -> JannoList a
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
forall {a}. Ord a => Eq (JannoList a)
forall a. Ord a => JannoList a -> JannoList a -> Bool
forall a. Ord a => JannoList a -> JannoList a -> Ordering
forall a. Ord a => JannoList a -> JannoList a -> JannoList a
$ccompare :: forall a. Ord a => JannoList a -> JannoList a -> Ordering
compare :: JannoList a -> JannoList a -> Ordering
$c< :: forall a. Ord a => JannoList a -> JannoList a -> Bool
< :: JannoList a -> JannoList a -> Bool
$c<= :: forall a. Ord a => JannoList a -> JannoList a -> Bool
<= :: JannoList a -> JannoList a -> Bool
$c> :: forall a. Ord a => JannoList a -> JannoList a -> Bool
> :: JannoList a -> JannoList a -> Bool
$c>= :: forall a. Ord a => JannoList a -> JannoList a -> Bool
>= :: JannoList a -> JannoList a -> Bool
$cmax :: forall a. Ord a => JannoList a -> JannoList a -> JannoList a
max :: JannoList a -> JannoList a -> JannoList a
$cmin :: forall a. Ord a => JannoList a -> JannoList a -> JannoList a
min :: JannoList a -> JannoList a -> JannoList a
Ord, (forall x. JannoList a -> Rep (JannoList a) x)
-> (forall x. Rep (JannoList a) x -> JannoList a)
-> Generic (JannoList a)
forall x. Rep (JannoList a) x -> JannoList a
forall x. JannoList a -> Rep (JannoList a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (JannoList a) x -> JannoList a
forall a x. JannoList a -> Rep (JannoList a) x
$cfrom :: forall a x. JannoList a -> Rep (JannoList a) x
from :: forall x. JannoList a -> Rep (JannoList a) x
$cto :: forall a x. Rep (JannoList a) x -> JannoList a
to :: forall x. Rep (JannoList a) x -> JannoList a
Generic, Int -> JannoList a -> ShowS
[JannoList a] -> ShowS
JannoList a -> String
(Int -> JannoList a -> ShowS)
-> (JannoList a -> String)
-> ([JannoList a] -> ShowS)
-> Show (JannoList a)
forall a. Show a => Int -> JannoList a -> ShowS
forall a. Show a => [JannoList a] -> ShowS
forall a. Show a => JannoList a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> JannoList a -> ShowS
showsPrec :: Int -> JannoList a -> ShowS
$cshow :: forall a. Show a => JannoList a -> String
show :: JannoList a -> String
$cshowList :: forall a. Show a => [JannoList a] -> ShowS
showList :: [JannoList a] -> ShowS
Show)

getMaybeJannoList :: Maybe (JannoList a) -> [a]
getMaybeJannoList :: forall a. Maybe (JannoList a) -> [a]
getMaybeJannoList Maybe (JannoList a)
Nothing  = []
getMaybeJannoList (Just JannoList a
x) = JannoList a -> [a]
forall a. JannoList a -> [a]
getJannoList JannoList a
x

type JannoStringList = JannoList String
type JannoIntList = JannoList Int

instance (Csv.ToField a, Show a) => Csv.ToField (JannoList a) where
    toField :: JannoList a -> ByteString
toField JannoList a
x = ByteString -> [ByteString] -> ByteString
Bchs.intercalate ByteString
";" ([ByteString] -> ByteString) -> [ByteString] -> ByteString
forall a b. (a -> b) -> a -> b
$ (a -> ByteString) -> [a] -> [ByteString]
forall a b. (a -> b) -> [a] -> [b]
map a -> ByteString
forall a. ToField a => a -> ByteString
Csv.toField ([a] -> [ByteString]) -> [a] -> [ByteString]
forall a b. (a -> b) -> a -> b
$ JannoList a -> [a]
forall a. JannoList a -> [a]
getJannoList JannoList a
x
instance (Csv.FromField a) => Csv.FromField (JannoList a) where
    parseField :: ByteString -> Parser (JannoList a)
parseField ByteString
x = ([a] -> JannoList a) -> Parser [a] -> Parser (JannoList a)
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [a] -> JannoList a
forall a. [a] -> JannoList a
JannoList (Parser [a] -> Parser (JannoList a))
-> ([ByteString] -> Parser [a])
-> [ByteString]
-> Parser (JannoList a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ByteString -> Parser a) -> [ByteString] -> Parser [a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ByteString -> Parser a
forall a. FromField a => ByteString -> Parser a
Csv.parseField ([ByteString] -> Parser (JannoList a))
-> [ByteString] -> Parser (JannoList a)
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> ByteString -> [ByteString]
Bchs.splitWith (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==Char
';') ByteString
x
instance (ToJSON a) => ToJSON (JannoList a) where
    toEncoding :: JannoList a -> Encoding
toEncoding (JannoList [a]
x) = [a] -> Encoding
forall a. ToJSON a => a -> Encoding
toEncoding [a]
x
instance (FromJSON a) => FromJSON (JannoList a) where
    parseJSON :: Value -> Parser (JannoList a)
parseJSON Value
x
        | Value -> Bool
isAesonString Value
x = [a] -> JannoList a
forall a. [a] -> JannoList a
JannoList ([a] -> JannoList a) -> (a -> [a]) -> a -> JannoList a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a]
forall {a}. a -> [a]
singleton (a -> JannoList a) -> Parser a -> Parser (JannoList a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser a
forall a. FromJSON a => Value -> Parser a
parseJSON Value
x
        | Bool
otherwise = [a] -> JannoList a
forall a. [a] -> JannoList a
JannoList ([a] -> JannoList a) -> Parser [a] -> Parser (JannoList a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser [a]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
x
        where
            isAesonString :: Value -> Bool
isAesonString (String Text
_) = Bool
True
            isAesonString Value
_          = Bool
False
            singleton :: a -> [a]
singleton a
a = [a
a]

-- | A datatype to collect additional, unpecified .janno file columns (a hashmap in cassava/Data.Csv)
newtype CsvNamedRecord = CsvNamedRecord Csv.NamedRecord deriving (Int -> CsvNamedRecord -> ShowS
[CsvNamedRecord] -> ShowS
CsvNamedRecord -> String
(Int -> CsvNamedRecord -> ShowS)
-> (CsvNamedRecord -> String)
-> ([CsvNamedRecord] -> ShowS)
-> Show CsvNamedRecord
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CsvNamedRecord -> ShowS
showsPrec :: Int -> CsvNamedRecord -> ShowS
$cshow :: CsvNamedRecord -> String
show :: CsvNamedRecord -> String
$cshowList :: [CsvNamedRecord] -> ShowS
showList :: [CsvNamedRecord] -> ShowS
Show, CsvNamedRecord -> CsvNamedRecord -> Bool
(CsvNamedRecord -> CsvNamedRecord -> Bool)
-> (CsvNamedRecord -> CsvNamedRecord -> Bool) -> Eq CsvNamedRecord
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CsvNamedRecord -> CsvNamedRecord -> Bool
== :: CsvNamedRecord -> CsvNamedRecord -> Bool
$c/= :: CsvNamedRecord -> CsvNamedRecord -> Bool
/= :: CsvNamedRecord -> CsvNamedRecord -> Bool
Eq, (forall x. CsvNamedRecord -> Rep CsvNamedRecord x)
-> (forall x. Rep CsvNamedRecord x -> CsvNamedRecord)
-> Generic CsvNamedRecord
forall x. Rep CsvNamedRecord x -> CsvNamedRecord
forall x. CsvNamedRecord -> Rep CsvNamedRecord x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CsvNamedRecord -> Rep CsvNamedRecord x
from :: forall x. CsvNamedRecord -> Rep CsvNamedRecord x
$cto :: forall x. Rep CsvNamedRecord x -> CsvNamedRecord
to :: forall x. Rep CsvNamedRecord x -> CsvNamedRecord
Generic)

getCsvNR :: CsvNamedRecord -> Csv.NamedRecord
getCsvNR :: CsvNamedRecord -> NamedRecord
getCsvNR (CsvNamedRecord NamedRecord
x) = NamedRecord
x

-- Aeson does not encode ByteStrings, so that's why we have to go through Text
instance ToJSON CsvNamedRecord where
    toJSON :: CsvNamedRecord -> Value
toJSON (CsvNamedRecord NamedRecord
x) =
        let listOfBSTuples :: [(ByteString, ByteString)]
listOfBSTuples = NamedRecord -> [(ByteString, ByteString)]
forall k v. HashMap k v -> [(k, v)]
HM.toList NamedRecord
x
            listOfTextTuples :: [(Text, Text)]
listOfTextTuples = ((ByteString, ByteString) -> (Text, Text))
-> [(ByteString, ByteString)] -> [(Text, Text)]
forall a b. (a -> b) -> [a] -> [b]
map (\(ByteString
a,ByteString
b) -> (ByteString -> Text
T.decodeUtf8 ByteString
a, ByteString -> Text
T.decodeUtf8 ByteString
b)) [(ByteString, ByteString)]
listOfBSTuples
        in [(Text, Text)] -> Value
forall a. ToJSON a => a -> Value
toJSON [(Text, Text)]
listOfTextTuples
instance FromJSON CsvNamedRecord where
    parseJSON :: Value -> Parser CsvNamedRecord
parseJSON Value
x
        | Value
x Value -> Value -> Bool
forall a. Eq a => a -> a -> Bool
== Value
emptyObject = CsvNamedRecord -> Parser CsvNamedRecord
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (CsvNamedRecord -> Parser CsvNamedRecord)
-> CsvNamedRecord -> Parser CsvNamedRecord
forall a b. (a -> b) -> a -> b
$ NamedRecord -> CsvNamedRecord
CsvNamedRecord (NamedRecord -> CsvNamedRecord) -> NamedRecord -> CsvNamedRecord
forall a b. (a -> b) -> a -> b
$ [(ByteString, ByteString)] -> NamedRecord
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList []
        | Bool
otherwise = do
            [(Text, Text)]
listOfTextTuples <- Value -> Parser [(Text, Text)]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
x -- :: [(T.Text, T.Text)]
            let listOfBSTuples :: [(ByteString, ByteString)]
listOfBSTuples = ((Text, Text) -> (ByteString, ByteString))
-> [(Text, Text)] -> [(ByteString, ByteString)]
forall a b. (a -> b) -> [a] -> [b]
map (\(Text
a,Text
b) -> (Text -> ByteString
T.encodeUtf8 Text
a, Text -> ByteString
T.encodeUtf8 Text
b)) [(Text, Text)]
listOfTextTuples
            CsvNamedRecord -> Parser CsvNamedRecord
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (CsvNamedRecord -> Parser CsvNamedRecord)
-> CsvNamedRecord -> Parser CsvNamedRecord
forall a b. (a -> b) -> a -> b
$ NamedRecord -> CsvNamedRecord
CsvNamedRecord (NamedRecord -> CsvNamedRecord) -> NamedRecord -> CsvNamedRecord
forall a b. (a -> b) -> a -> b
$ [(ByteString, ByteString)] -> NamedRecord
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList [(ByteString, ByteString)]
listOfBSTuples

-- | A  data type to represent a janno file
newtype JannoRows = JannoRows [JannoRow]
    deriving (Int -> JannoRows -> ShowS
[JannoRows] -> ShowS
JannoRows -> String
(Int -> JannoRows -> ShowS)
-> (JannoRows -> String)
-> ([JannoRows] -> ShowS)
-> Show JannoRows
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JannoRows -> ShowS
showsPrec :: Int -> JannoRows -> ShowS
$cshow :: JannoRows -> String
show :: JannoRows -> String
$cshowList :: [JannoRows] -> ShowS
showList :: [JannoRows] -> ShowS
Show, JannoRows -> JannoRows -> Bool
(JannoRows -> JannoRows -> Bool)
-> (JannoRows -> JannoRows -> Bool) -> Eq JannoRows
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoRows -> JannoRows -> Bool
== :: JannoRows -> JannoRows -> Bool
$c/= :: JannoRows -> JannoRows -> Bool
/= :: JannoRows -> JannoRows -> Bool
Eq, (forall x. JannoRows -> Rep JannoRows x)
-> (forall x. Rep JannoRows x -> JannoRows) -> Generic JannoRows
forall x. Rep JannoRows x -> JannoRows
forall x. JannoRows -> Rep JannoRows x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoRows -> Rep JannoRows x
from :: forall x. JannoRows -> Rep JannoRows x
$cto :: forall x. Rep JannoRows x -> JannoRows
to :: forall x. Rep JannoRows x -> JannoRows
Generic)

instance Semigroup JannoRows where
    (JannoRows [JannoRow]
j1) <> :: JannoRows -> JannoRows -> JannoRows
<> (JannoRows [JannoRow]
j2) = [JannoRow] -> JannoRows
JannoRows ([JannoRow] -> JannoRows) -> [JannoRow] -> JannoRows
forall a b. (a -> b) -> a -> b
$ [JannoRow]
j1 [JannoRow] -> [JannoRow] -> [JannoRow]
`combineTwoJannos` [JannoRow]
j2
        where
        combineTwoJannos :: [JannoRow] -> [JannoRow] -> [JannoRow]
        combineTwoJannos :: [JannoRow] -> [JannoRow] -> [JannoRow]
combineTwoJannos [JannoRow]
janno1 [JannoRow]
janno2 =
            let simpleJannoSum :: [JannoRow]
simpleJannoSum = [JannoRow]
janno1 [JannoRow] -> [JannoRow] -> [JannoRow]
forall a. [a] -> [a] -> [a]
++ [JannoRow]
janno2
                toAddColNames :: [ByteString]
toAddColNames = NamedRecord -> [ByteString]
forall k v. HashMap k v -> [k]
HM.keys ([NamedRecord] -> NamedRecord
forall k v. (Eq k, Hashable k) => [HashMap k v] -> HashMap k v
HM.unions ((JannoRow -> NamedRecord) -> [JannoRow] -> [NamedRecord]
forall a b. (a -> b) -> [a] -> [b]
map (CsvNamedRecord -> NamedRecord
getCsvNR (CsvNamedRecord -> NamedRecord)
-> (JannoRow -> CsvNamedRecord) -> JannoRow -> NamedRecord
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JannoRow -> CsvNamedRecord
jAdditionalColumns) [JannoRow]
simpleJannoSum))
                toAddEmptyCols :: NamedRecord
toAddEmptyCols = [(ByteString, ByteString)] -> NamedRecord
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList ((ByteString -> (ByteString, ByteString))
-> [ByteString] -> [(ByteString, ByteString)]
forall a b. (a -> b) -> [a] -> [b]
map (\ByteString
k -> (ByteString
k, ByteString
"n/a")) [ByteString]
toAddColNames)
            in (JannoRow -> JannoRow) -> [JannoRow] -> [JannoRow]
forall a b. (a -> b) -> [a] -> [b]
map (NamedRecord -> JannoRow -> JannoRow
addEmptyAddColsToJannoRow NamedRecord
toAddEmptyCols) [JannoRow]
simpleJannoSum
        addEmptyAddColsToJannoRow :: Csv.NamedRecord -> JannoRow -> JannoRow
        addEmptyAddColsToJannoRow :: NamedRecord -> JannoRow -> JannoRow
addEmptyAddColsToJannoRow NamedRecord
toAdd JannoRow
x =
            JannoRow
x { jAdditionalColumns :: CsvNamedRecord
jAdditionalColumns = NamedRecord -> CsvNamedRecord
CsvNamedRecord (NamedRecord -> CsvNamedRecord) -> NamedRecord -> CsvNamedRecord
forall a b. (a -> b) -> a -> b
$ NamedRecord -> NamedRecord -> NamedRecord
fillAddCols NamedRecord
toAdd (CsvNamedRecord -> NamedRecord
getCsvNR (CsvNamedRecord -> NamedRecord) -> CsvNamedRecord -> NamedRecord
forall a b. (a -> b) -> a -> b
$ JannoRow -> CsvNamedRecord
jAdditionalColumns JannoRow
x) }
        fillAddCols :: Csv.NamedRecord -> Csv.NamedRecord -> Csv.NamedRecord
        fillAddCols :: NamedRecord -> NamedRecord -> NamedRecord
fillAddCols NamedRecord
toAdd NamedRecord
cur = NamedRecord -> NamedRecord -> NamedRecord
forall k v.
(Eq k, Hashable k) =>
HashMap k v -> HashMap k v -> HashMap k v
HM.union NamedRecord
cur (NamedRecord
toAdd NamedRecord -> NamedRecord -> NamedRecord
forall k v w.
(Eq k, Hashable k) =>
HashMap k v -> HashMap k w -> HashMap k v
`HM.difference` NamedRecord
cur)

instance Monoid JannoRows where
    mempty :: JannoRows
mempty = [JannoRow] -> JannoRows
JannoRows []
    mconcat :: [JannoRows] -> JannoRows
mconcat = (JannoRows -> JannoRows -> JannoRows)
-> JannoRows -> [JannoRows] -> JannoRows
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' JannoRows -> JannoRows -> JannoRows
forall a. Monoid a => a -> a -> a
mappend JannoRows
forall a. Monoid a => a
mempty

instance ToJSON JannoRows where
    toEncoding :: JannoRows -> Encoding
toEncoding = Options -> JannoRows -> Encoding
forall a.
(Generic a, GToJSON' Encoding Zero (Rep a)) =>
Options -> a -> Encoding
genericToEncoding Options
defaultOptions
instance FromJSON JannoRows

-- | A data type to represent a sample/janno file row
-- See https://github.com/poseidon-framework/poseidon2-schema/blob/master/janno_columns.tsv
-- for more details
data JannoRow = JannoRow
    { JannoRow -> String
jPoseidonID                 :: String
    , JannoRow -> JannoSex
jGeneticSex                 :: JannoSex
    , JannoRow -> JannoStringList
jGroupName                  :: JannoStringList
    , JannoRow -> Maybe JannoStringList
jAlternativeIDs             :: Maybe JannoStringList
    , JannoRow -> Maybe JannoStringList
jRelationTo                 :: Maybe JannoStringList
    , JannoRow -> Maybe JannoRelationDegreeList
jRelationDegree             :: Maybe JannoRelationDegreeList
    , JannoRow -> Maybe JannoStringList
jRelationType               :: Maybe JannoStringList
    , JannoRow -> Maybe String
jRelationNote               :: Maybe String
    , JannoRow -> Maybe String
jCollectionID               :: Maybe String
    , JannoRow -> Maybe String
jCountry                    :: Maybe String
    , JannoRow -> Maybe JannoCountry
jCountryISO                 :: Maybe JannoCountry
    , JannoRow -> Maybe String
jLocation                   :: Maybe String
    , JannoRow -> Maybe String
jSite                       :: Maybe String
    , JannoRow -> Maybe Latitude
jLatitude                   :: Maybe Latitude
    , JannoRow -> Maybe Longitude
jLongitude                  :: Maybe Longitude
    , JannoRow -> Maybe JannoDateType
jDateType                   :: Maybe JannoDateType
    , JannoRow -> Maybe JannoStringList
jDateC14Labnr               :: Maybe JannoStringList
    , JannoRow -> Maybe JannoIntList
jDateC14UncalBP             :: Maybe JannoIntList
    , JannoRow -> Maybe JannoIntList
jDateC14UncalBPErr          :: Maybe JannoIntList
    , JannoRow -> Maybe BCADAge
jDateBCADStart              :: Maybe BCADAge
    , JannoRow -> Maybe BCADAge
jDateBCADMedian             :: Maybe BCADAge
    , JannoRow -> Maybe BCADAge
jDateBCADStop               :: Maybe BCADAge
    , JannoRow -> Maybe String
jDateNote                   :: Maybe String
    , JannoRow -> Maybe String
jMTHaplogroup               :: Maybe String
    , JannoRow -> Maybe String
jYHaplogroup                :: Maybe String
    , JannoRow -> Maybe JannoStringList
jSourceTissue               :: Maybe JannoStringList
    , JannoRow -> Maybe Int
jNrLibraries                :: Maybe Int
    , JannoRow -> Maybe JannoStringList
jLibraryNames               :: Maybe JannoStringList
    , JannoRow -> Maybe (JannoList JannoCaptureType)
jCaptureType                :: Maybe (JannoList JannoCaptureType)
    , JannoRow -> Maybe JannoUDG
jUDG                        :: Maybe JannoUDG
    , JannoRow -> Maybe JannoLibraryBuilt
jLibraryBuilt               :: Maybe JannoLibraryBuilt
    , JannoRow -> Maybe JannoGenotypePloidy
jGenotypePloidy             :: Maybe JannoGenotypePloidy
    , JannoRow -> Maybe JURI
jDataPreparationPipelineURL :: Maybe JURI
    , JannoRow -> Maybe Percent
jEndogenous                 :: Maybe Percent
    , JannoRow -> Maybe Int
jNrSNPs                     :: Maybe Int
    , JannoRow -> Maybe Double
jCoverageOnTargets          :: Maybe Double
    , JannoRow -> Maybe Percent
jDamage                     :: Maybe Percent
    , JannoRow -> Maybe JannoStringList
jContamination              :: Maybe JannoStringList
    , JannoRow -> Maybe JannoStringList
jContaminationErr           :: Maybe JannoStringList
    , JannoRow -> Maybe JannoStringList
jContaminationMeas          :: Maybe JannoStringList
    , JannoRow -> Maybe String
jContaminationNote          :: Maybe String
    , JannoRow -> Maybe (JannoList AccessionID)
jGeneticSourceAccessionIDs  :: Maybe (JannoList AccessionID)
    , JannoRow -> Maybe String
jPrimaryContact             :: Maybe String
    , JannoRow -> Maybe JannoStringList
jPublication                :: Maybe JannoStringList
    , JannoRow -> Maybe String
jComments                   :: Maybe String
    , JannoRow -> Maybe JannoStringList
jKeywords                   :: Maybe JannoStringList
    , JannoRow -> CsvNamedRecord
jAdditionalColumns          :: CsvNamedRecord
    }
    deriving (Int -> JannoRow -> ShowS
[JannoRow] -> ShowS
JannoRow -> String
(Int -> JannoRow -> ShowS)
-> (JannoRow -> String) -> ([JannoRow] -> ShowS) -> Show JannoRow
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JannoRow -> ShowS
showsPrec :: Int -> JannoRow -> ShowS
$cshow :: JannoRow -> String
show :: JannoRow -> String
$cshowList :: [JannoRow] -> ShowS
showList :: [JannoRow] -> ShowS
Show, JannoRow -> JannoRow -> Bool
(JannoRow -> JannoRow -> Bool)
-> (JannoRow -> JannoRow -> Bool) -> Eq JannoRow
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JannoRow -> JannoRow -> Bool
== :: JannoRow -> JannoRow -> Bool
$c/= :: JannoRow -> JannoRow -> Bool
/= :: JannoRow -> JannoRow -> Bool
Eq, (forall x. JannoRow -> Rep JannoRow x)
-> (forall x. Rep JannoRow x -> JannoRow) -> Generic JannoRow
forall x. Rep JannoRow x -> JannoRow
forall x. JannoRow -> Rep JannoRow x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JannoRow -> Rep JannoRow x
from :: forall x. JannoRow -> Rep JannoRow x
$cto :: forall x. Rep JannoRow x -> JannoRow
to :: forall x. Rep JannoRow x -> JannoRow
Generic)

-- This header also defines the output column order when writing to csv!
jannoHeader :: [Bchs.ByteString]
jannoHeader :: [ByteString]
jannoHeader = [
      ByteString
"Poseidon_ID"
    , ByteString
"Genetic_Sex"
    , ByteString
"Group_Name"
    , ByteString
"Alternative_IDs"
    , ByteString
"Relation_To"
    , ByteString
"Relation_Degree"
    , ByteString
"Relation_Type"
    , ByteString
"Relation_Note"
    , ByteString
"Collection_ID"
    , ByteString
"Country"
    , ByteString
"Country_ISO"
    , ByteString
"Location"
    , ByteString
"Site"
    , ByteString
"Latitude"
    , ByteString
"Longitude"
    , ByteString
"Date_Type"
    , ByteString
"Date_C14_Labnr"
    , ByteString
"Date_C14_Uncal_BP"
    , ByteString
"Date_C14_Uncal_BP_Err"
    , ByteString
"Date_BC_AD_Start"
    , ByteString
"Date_BC_AD_Median"
    , ByteString
"Date_BC_AD_Stop"
    , ByteString
"Date_Note"
    , ByteString
"MT_Haplogroup"
    , ByteString
"Y_Haplogroup"
    , ByteString
"Source_Tissue"
    , ByteString
"Nr_Libraries"
    , ByteString
"Library_Names"
    , ByteString
"Capture_Type"
    , ByteString
"UDG"
    , ByteString
"Library_Built"
    , ByteString
"Genotype_Ploidy"
    , ByteString
"Data_Preparation_Pipeline_URL"
    , ByteString
"Endogenous"
    , ByteString
"Nr_SNPs"
    , ByteString
"Coverage_on_Target_SNPs"
    , ByteString
"Damage"
    , ByteString
"Contamination"
    , ByteString
"Contamination_Err"
    , ByteString
"Contamination_Meas"
    , ByteString
"Contamination_Note"
    , ByteString
"Genetic_Source_Accession_IDs"
    , ByteString
"Primary_Contact"
    , ByteString
"Publication"
    , ByteString
"Note"
    , ByteString
"Keywords"
    ]

instance Csv.DefaultOrdered JannoRow where
    headerOrder :: JannoRow -> Header
headerOrder JannoRow
_ = [ByteString] -> Header
Csv.header [ByteString]
jannoHeader

jannoHeaderString :: [String]
jannoHeaderString :: JannoRowWarnings
jannoHeaderString = (ByteString -> String) -> [ByteString] -> JannoRowWarnings
forall a b. (a -> b) -> [a] -> [b]
map ByteString -> String
Bchs.unpack [ByteString]
jannoHeader

-- This hashmap represents an empty janno file with all normal, specified columns
jannoRefHashMap :: HM.HashMap Bchs.ByteString ()
jannoRefHashMap :: HashMap ByteString ()
jannoRefHashMap = [(ByteString, ())] -> HashMap ByteString ()
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList ([(ByteString, ())] -> HashMap ByteString ())
-> [(ByteString, ())] -> HashMap ByteString ()
forall a b. (a -> b) -> a -> b
$ (ByteString -> (ByteString, ()))
-> [ByteString] -> [(ByteString, ())]
forall a b. (a -> b) -> [a] -> [b]
map (\ByteString
x -> (ByteString
x, ())) [ByteString]
jannoHeader

instance ToJSON JannoRow where
    toEncoding :: JannoRow -> Encoding
toEncoding = Options -> JannoRow -> Encoding
forall a.
(Generic a, GToJSON' Encoding Zero (Rep a)) =>
Options -> a -> Encoding
genericToEncoding (Options
defaultOptions {omitNothingFields :: Bool
omitNothingFields = Bool
True})

instance FromJSON JannoRow

instance Csv.FromNamedRecord JannoRow where
    parseNamedRecord :: NamedRecord -> Parser JannoRow
parseNamedRecord NamedRecord
m = String
-> JannoSex
-> JannoStringList
-> Maybe JannoStringList
-> Maybe JannoStringList
-> Maybe JannoRelationDegreeList
-> Maybe JannoStringList
-> Maybe String
-> Maybe String
-> Maybe String
-> Maybe JannoCountry
-> Maybe String
-> Maybe String
-> Maybe Latitude
-> Maybe Longitude
-> Maybe JannoDateType
-> Maybe JannoStringList
-> Maybe JannoIntList
-> Maybe JannoIntList
-> Maybe BCADAge
-> Maybe BCADAge
-> Maybe BCADAge
-> Maybe String
-> Maybe String
-> Maybe String
-> Maybe JannoStringList
-> Maybe Int
-> Maybe JannoStringList
-> Maybe (JannoList JannoCaptureType)
-> Maybe JannoUDG
-> Maybe JannoLibraryBuilt
-> Maybe JannoGenotypePloidy
-> Maybe JURI
-> Maybe Percent
-> Maybe Int
-> Maybe Double
-> Maybe Percent
-> Maybe JannoStringList
-> Maybe JannoStringList
-> Maybe JannoStringList
-> Maybe String
-> Maybe (JannoList AccessionID)
-> Maybe String
-> Maybe JannoStringList
-> Maybe String
-> Maybe JannoStringList
-> CsvNamedRecord
-> JannoRow
JannoRow
        (String
 -> JannoSex
 -> JannoStringList
 -> Maybe JannoStringList
 -> Maybe JannoStringList
 -> Maybe JannoRelationDegreeList
 -> Maybe JannoStringList
 -> Maybe String
 -> Maybe String
 -> Maybe String
 -> Maybe JannoCountry
 -> Maybe String
 -> Maybe String
 -> Maybe Latitude
 -> Maybe Longitude
 -> Maybe JannoDateType
 -> Maybe JannoStringList
 -> Maybe JannoIntList
 -> Maybe JannoIntList
 -> Maybe BCADAge
 -> Maybe BCADAge
 -> Maybe BCADAge
 -> Maybe String
 -> Maybe String
 -> Maybe String
 -> Maybe JannoStringList
 -> Maybe Int
 -> Maybe JannoStringList
 -> Maybe (JannoList JannoCaptureType)
 -> Maybe JannoUDG
 -> Maybe JannoLibraryBuilt
 -> Maybe JannoGenotypePloidy
 -> Maybe JURI
 -> Maybe Percent
 -> Maybe Int
 -> Maybe Double
 -> Maybe Percent
 -> Maybe JannoStringList
 -> Maybe JannoStringList
 -> Maybe JannoStringList
 -> Maybe String
 -> Maybe (JannoList AccessionID)
 -> Maybe String
 -> Maybe JannoStringList
 -> Maybe String
 -> Maybe JannoStringList
 -> CsvNamedRecord
 -> JannoRow)
-> Parser String
-> Parser
     (JannoSex
      -> JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoRelationDegreeList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoCountry
      -> Maybe String
      -> Maybe String
      -> Maybe Latitude
      -> Maybe Longitude
      -> Maybe JannoDateType
      -> Maybe JannoStringList
      -> Maybe JannoIntList
      -> Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NamedRecord -> ByteString -> Parser String
forall a. FromField a => NamedRecord -> ByteString -> Parser a
filterLookup         NamedRecord
m ByteString
"Poseidon_ID"
        Parser
  (JannoSex
   -> JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoRelationDegreeList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoCountry
   -> Maybe String
   -> Maybe String
   -> Maybe Latitude
   -> Maybe Longitude
   -> Maybe JannoDateType
   -> Maybe JannoStringList
   -> Maybe JannoIntList
   -> Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser JannoSex
-> Parser
     (JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoRelationDegreeList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoCountry
      -> Maybe String
      -> Maybe String
      -> Maybe Latitude
      -> Maybe Longitude
      -> Maybe JannoDateType
      -> Maybe JannoStringList
      -> Maybe JannoIntList
      -> Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser JannoSex
forall a. FromField a => NamedRecord -> ByteString -> Parser a
filterLookup         NamedRecord
m ByteString
"Genetic_Sex"
        Parser
  (JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoRelationDegreeList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoCountry
   -> Maybe String
   -> Maybe String
   -> Maybe Latitude
   -> Maybe Longitude
   -> Maybe JannoDateType
   -> Maybe JannoStringList
   -> Maybe JannoIntList
   -> Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser JannoStringList
-> Parser
     (Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoRelationDegreeList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoCountry
      -> Maybe String
      -> Maybe String
      -> Maybe Latitude
      -> Maybe Longitude
      -> Maybe JannoDateType
      -> Maybe JannoStringList
      -> Maybe JannoIntList
      -> Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser JannoStringList
forall a. FromField a => NamedRecord -> ByteString -> Parser a
filterLookup         NamedRecord
m ByteString
"Group_Name"
        Parser
  (Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoRelationDegreeList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoCountry
   -> Maybe String
   -> Maybe String
   -> Maybe Latitude
   -> Maybe Longitude
   -> Maybe JannoDateType
   -> Maybe JannoStringList
   -> Maybe JannoIntList
   -> Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoStringList)
-> Parser
     (Maybe JannoStringList
      -> Maybe JannoRelationDegreeList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoCountry
      -> Maybe String
      -> Maybe String
      -> Maybe Latitude
      -> Maybe Longitude
      -> Maybe JannoDateType
      -> Maybe JannoStringList
      -> Maybe JannoIntList
      -> Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoStringList)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Alternative_IDs"
        Parser
  (Maybe JannoStringList
   -> Maybe JannoRelationDegreeList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoCountry
   -> Maybe String
   -> Maybe String
   -> Maybe Latitude
   -> Maybe Longitude
   -> Maybe JannoDateType
   -> Maybe JannoStringList
   -> Maybe JannoIntList
   -> Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoStringList)
-> Parser
     (Maybe JannoRelationDegreeList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoCountry
      -> Maybe String
      -> Maybe String
      -> Maybe Latitude
      -> Maybe Longitude
      -> Maybe JannoDateType
      -> Maybe JannoStringList
      -> Maybe JannoIntList
      -> Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoStringList)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Relation_To"
        Parser
  (Maybe JannoRelationDegreeList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoCountry
   -> Maybe String
   -> Maybe String
   -> Maybe Latitude
   -> Maybe Longitude
   -> Maybe JannoDateType
   -> Maybe JannoStringList
   -> Maybe JannoIntList
   -> Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoRelationDegreeList)
-> Parser
     (Maybe JannoStringList
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoCountry
      -> Maybe String
      -> Maybe String
      -> Maybe Latitude
      -> Maybe Longitude
      -> Maybe JannoDateType
      -> Maybe JannoStringList
      -> Maybe JannoIntList
      -> Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoRelationDegreeList)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Relation_Degree"
        Parser
  (Maybe JannoStringList
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoCountry
   -> Maybe String
   -> Maybe String
   -> Maybe Latitude
   -> Maybe Longitude
   -> Maybe JannoDateType
   -> Maybe JannoStringList
   -> Maybe JannoIntList
   -> Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoStringList)
-> Parser
     (Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoCountry
      -> Maybe String
      -> Maybe String
      -> Maybe Latitude
      -> Maybe Longitude
      -> Maybe JannoDateType
      -> Maybe JannoStringList
      -> Maybe JannoIntList
      -> Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoStringList)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Relation_Type"
        Parser
  (Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoCountry
   -> Maybe String
   -> Maybe String
   -> Maybe Latitude
   -> Maybe Longitude
   -> Maybe JannoDateType
   -> Maybe JannoStringList
   -> Maybe JannoIntList
   -> Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe String)
-> Parser
     (Maybe String
      -> Maybe String
      -> Maybe JannoCountry
      -> Maybe String
      -> Maybe String
      -> Maybe Latitude
      -> Maybe Longitude
      -> Maybe JannoDateType
      -> Maybe JannoStringList
      -> Maybe JannoIntList
      -> Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe String)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Relation_Note"
        Parser
  (Maybe String
   -> Maybe String
   -> Maybe JannoCountry
   -> Maybe String
   -> Maybe String
   -> Maybe Latitude
   -> Maybe Longitude
   -> Maybe JannoDateType
   -> Maybe JannoStringList
   -> Maybe JannoIntList
   -> Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe String)
-> Parser
     (Maybe String
      -> Maybe JannoCountry
      -> Maybe String
      -> Maybe String
      -> Maybe Latitude
      -> Maybe Longitude
      -> Maybe JannoDateType
      -> Maybe JannoStringList
      -> Maybe JannoIntList
      -> Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe String)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Collection_ID"
        Parser
  (Maybe String
   -> Maybe JannoCountry
   -> Maybe String
   -> Maybe String
   -> Maybe Latitude
   -> Maybe Longitude
   -> Maybe JannoDateType
   -> Maybe JannoStringList
   -> Maybe JannoIntList
   -> Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe String)
-> Parser
     (Maybe JannoCountry
      -> Maybe String
      -> Maybe String
      -> Maybe Latitude
      -> Maybe Longitude
      -> Maybe JannoDateType
      -> Maybe JannoStringList
      -> Maybe JannoIntList
      -> Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe String)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Country"
        Parser
  (Maybe JannoCountry
   -> Maybe String
   -> Maybe String
   -> Maybe Latitude
   -> Maybe Longitude
   -> Maybe JannoDateType
   -> Maybe JannoStringList
   -> Maybe JannoIntList
   -> Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoCountry)
-> Parser
     (Maybe String
      -> Maybe String
      -> Maybe Latitude
      -> Maybe Longitude
      -> Maybe JannoDateType
      -> Maybe JannoStringList
      -> Maybe JannoIntList
      -> Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoCountry)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Country_ISO"
        Parser
  (Maybe String
   -> Maybe String
   -> Maybe Latitude
   -> Maybe Longitude
   -> Maybe JannoDateType
   -> Maybe JannoStringList
   -> Maybe JannoIntList
   -> Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe String)
-> Parser
     (Maybe String
      -> Maybe Latitude
      -> Maybe Longitude
      -> Maybe JannoDateType
      -> Maybe JannoStringList
      -> Maybe JannoIntList
      -> Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe String)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Location"
        Parser
  (Maybe String
   -> Maybe Latitude
   -> Maybe Longitude
   -> Maybe JannoDateType
   -> Maybe JannoStringList
   -> Maybe JannoIntList
   -> Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe String)
-> Parser
     (Maybe Latitude
      -> Maybe Longitude
      -> Maybe JannoDateType
      -> Maybe JannoStringList
      -> Maybe JannoIntList
      -> Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe String)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Site"
        Parser
  (Maybe Latitude
   -> Maybe Longitude
   -> Maybe JannoDateType
   -> Maybe JannoStringList
   -> Maybe JannoIntList
   -> Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe Latitude)
-> Parser
     (Maybe Longitude
      -> Maybe JannoDateType
      -> Maybe JannoStringList
      -> Maybe JannoIntList
      -> Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe Latitude)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Latitude"
        Parser
  (Maybe Longitude
   -> Maybe JannoDateType
   -> Maybe JannoStringList
   -> Maybe JannoIntList
   -> Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe Longitude)
-> Parser
     (Maybe JannoDateType
      -> Maybe JannoStringList
      -> Maybe JannoIntList
      -> Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe Longitude)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Longitude"
        Parser
  (Maybe JannoDateType
   -> Maybe JannoStringList
   -> Maybe JannoIntList
   -> Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoDateType)
-> Parser
     (Maybe JannoStringList
      -> Maybe JannoIntList
      -> Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoDateType)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Date_Type"
        Parser
  (Maybe JannoStringList
   -> Maybe JannoIntList
   -> Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoStringList)
-> Parser
     (Maybe JannoIntList
      -> Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoStringList)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Date_C14_Labnr"
        Parser
  (Maybe JannoIntList
   -> Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoIntList)
-> Parser
     (Maybe JannoIntList
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoIntList)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Date_C14_Uncal_BP"
        Parser
  (Maybe JannoIntList
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoIntList)
-> Parser
     (Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoIntList)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Date_C14_Uncal_BP_Err"
        Parser
  (Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe BCADAge)
-> Parser
     (Maybe BCADAge
      -> Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe BCADAge)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Date_BC_AD_Start"
        Parser
  (Maybe BCADAge
   -> Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe BCADAge)
-> Parser
     (Maybe BCADAge
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe BCADAge)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Date_BC_AD_Median"
        Parser
  (Maybe BCADAge
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe BCADAge)
-> Parser
     (Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe BCADAge)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Date_BC_AD_Stop"
        Parser
  (Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe String)
-> Parser
     (Maybe String
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe String)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Date_Note"
        Parser
  (Maybe String
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe String)
-> Parser
     (Maybe String
      -> Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe String)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"MT_Haplogroup"
        Parser
  (Maybe String
   -> Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe String)
-> Parser
     (Maybe JannoStringList
      -> Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe String)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Y_Haplogroup"
        Parser
  (Maybe JannoStringList
   -> Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoStringList)
-> Parser
     (Maybe Int
      -> Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoStringList)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Source_Tissue"
        Parser
  (Maybe Int
   -> Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe Int)
-> Parser
     (Maybe JannoStringList
      -> Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe Int)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Nr_Libraries"
        Parser
  (Maybe JannoStringList
   -> Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoStringList)
-> Parser
     (Maybe (JannoList JannoCaptureType)
      -> Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoStringList)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Library_Names"
        Parser
  (Maybe (JannoList JannoCaptureType)
   -> Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe (JannoList JannoCaptureType))
-> Parser
     (Maybe JannoUDG
      -> Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord
-> ByteString -> Parser (Maybe (JannoList JannoCaptureType))
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Capture_Type"
        Parser
  (Maybe JannoUDG
   -> Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoUDG)
-> Parser
     (Maybe JannoLibraryBuilt
      -> Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoUDG)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"UDG"
        Parser
  (Maybe JannoLibraryBuilt
   -> Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoLibraryBuilt)
-> Parser
     (Maybe JannoGenotypePloidy
      -> Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoLibraryBuilt)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Library_Built"
        Parser
  (Maybe JannoGenotypePloidy
   -> Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoGenotypePloidy)
-> Parser
     (Maybe JURI
      -> Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoGenotypePloidy)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Genotype_Ploidy"
        Parser
  (Maybe JURI
   -> Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JURI)
-> Parser
     (Maybe Percent
      -> Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JURI)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Data_Preparation_Pipeline_URL"
        Parser
  (Maybe Percent
   -> Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe Percent)
-> Parser
     (Maybe Int
      -> Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe Percent)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Endogenous"
        Parser
  (Maybe Int
   -> Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe Int)
-> Parser
     (Maybe Double
      -> Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe Int)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Nr_SNPs"
        Parser
  (Maybe Double
   -> Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe Double)
-> Parser
     (Maybe Percent
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe Double)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Coverage_on_Target_SNPs"
        Parser
  (Maybe Percent
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe Percent)
-> Parser
     (Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe Percent)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Damage"
        Parser
  (Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoStringList)
-> Parser
     (Maybe JannoStringList
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoStringList)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Contamination"
        Parser
  (Maybe JannoStringList
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoStringList)
-> Parser
     (Maybe JannoStringList
      -> Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoStringList)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Contamination_Err"
        Parser
  (Maybe JannoStringList
   -> Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoStringList)
-> Parser
     (Maybe String
      -> Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoStringList)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Contamination_Meas"
        Parser
  (Maybe String
   -> Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe String)
-> Parser
     (Maybe (JannoList AccessionID)
      -> Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe String)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Contamination_Note"
        Parser
  (Maybe (JannoList AccessionID)
   -> Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe (JannoList AccessionID))
-> Parser
     (Maybe String
      -> Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe (JannoList AccessionID))
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Genetic_Source_Accession_IDs"
        Parser
  (Maybe String
   -> Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe String)
-> Parser
     (Maybe JannoStringList
      -> Maybe String
      -> Maybe JannoStringList
      -> CsvNamedRecord
      -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe String)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Primary_Contact"
        Parser
  (Maybe JannoStringList
   -> Maybe String
   -> Maybe JannoStringList
   -> CsvNamedRecord
   -> JannoRow)
-> Parser (Maybe JannoStringList)
-> Parser
     (Maybe String
      -> Maybe JannoStringList -> CsvNamedRecord -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoStringList)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Publication"
        Parser
  (Maybe String
   -> Maybe JannoStringList -> CsvNamedRecord -> JannoRow)
-> Parser (Maybe String)
-> Parser (Maybe JannoStringList -> CsvNamedRecord -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe String)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Note"
        Parser (Maybe JannoStringList -> CsvNamedRecord -> JannoRow)
-> Parser (Maybe JannoStringList)
-> Parser (CsvNamedRecord -> JannoRow)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NamedRecord -> ByteString -> Parser (Maybe JannoStringList)
forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
"Keywords"
        -- beyond that read everything that is not in the set of defined variables
        -- as a separate hashmap
        Parser (CsvNamedRecord -> JannoRow)
-> Parser CsvNamedRecord -> Parser JannoRow
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> CsvNamedRecord -> Parser CsvNamedRecord
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NamedRecord -> CsvNamedRecord
CsvNamedRecord (NamedRecord
m NamedRecord -> HashMap ByteString () -> NamedRecord
forall k v w.
(Eq k, Hashable k) =>
HashMap k v -> HashMap k w -> HashMap k v
`HM.difference` HashMap ByteString ()
jannoRefHashMap))

filterLookup :: Csv.FromField a => Csv.NamedRecord -> Bchs.ByteString -> Csv.Parser a
filterLookup :: forall a. FromField a => NamedRecord -> ByteString -> Parser a
filterLookup NamedRecord
m ByteString
name = Parser a
-> (ByteString -> Parser a) -> Maybe ByteString -> Parser a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Parser a
forall a. Parser a
forall (f :: * -> *) a. Alternative f => f a
empty ByteString -> Parser a
forall a. FromField a => ByteString -> Parser a
Csv.parseField (Maybe ByteString -> Parser a)
-> (Maybe ByteString -> Maybe ByteString)
-> Maybe ByteString
-> Parser a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe ByteString -> Maybe ByteString
cleanInput (Maybe ByteString -> Parser a) -> Maybe ByteString -> Parser a
forall a b. (a -> b) -> a -> b
$ ByteString -> NamedRecord -> Maybe ByteString
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup ByteString
name NamedRecord
m

filterLookupOptional :: Csv.FromField a => Csv.NamedRecord -> Bchs.ByteString -> Csv.Parser (Maybe a)
filterLookupOptional :: forall a.
FromField a =>
NamedRecord -> ByteString -> Parser (Maybe a)
filterLookupOptional NamedRecord
m ByteString
name = Parser (Maybe a)
-> (ByteString -> Parser (Maybe a))
-> Maybe ByteString
-> Parser (Maybe a)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe a -> Parser (Maybe a)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe a
forall a. Maybe a
Nothing) ByteString -> Parser (Maybe a)
forall a. FromField a => ByteString -> Parser a
Csv.parseField (Maybe ByteString -> Parser (Maybe a))
-> (Maybe ByteString -> Maybe ByteString)
-> Maybe ByteString
-> Parser (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe ByteString -> Maybe ByteString
cleanInput (Maybe ByteString -> Parser (Maybe a))
-> Maybe ByteString -> Parser (Maybe a)
forall a b. (a -> b) -> a -> b
$ ByteString -> NamedRecord -> Maybe ByteString
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup ByteString
name NamedRecord
m

cleanInput :: Maybe Bchs.ByteString -> Maybe Bchs.ByteString
cleanInput :: Maybe ByteString -> Maybe ByteString
cleanInput Maybe ByteString
Nothing           = Maybe ByteString
forall a. Maybe a
Nothing
cleanInput (Just ByteString
rawInputBS) = ByteString -> Maybe ByteString
transNA (ByteString -> Maybe ByteString) -> ByteString -> Maybe ByteString
forall a b. (a -> b) -> a -> b
$ ByteString -> ByteString
trimWS (ByteString -> ByteString)
-> (ByteString -> ByteString) -> ByteString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
removeNoBreakSpace (ByteString -> ByteString) -> ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ ByteString
rawInputBS
    where
        trimWS :: Bchs.ByteString -> Bchs.ByteString
        trimWS :: ByteString -> ByteString
trimWS = (Char -> Bool) -> ByteString -> ByteString
Bchs.dropWhile Char -> Bool
isSpace (ByteString -> ByteString)
-> (ByteString -> ByteString) -> ByteString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ByteString -> ByteString
Bchs.dropWhileEnd Char -> Bool
isSpace
        removeNoBreakSpace :: Bchs.ByteString -> Bchs.ByteString
        removeNoBreakSpace :: ByteString -> ByteString
removeNoBreakSpace ByteString
x
            | Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ ByteString -> ByteString -> Bool
Bchs.isInfixOf ByteString
"\194\160" ByteString
x = ByteString
x
            | Bool
otherwise = ByteString -> ByteString
removeNoBreakSpace (ByteString -> ByteString) -> ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ (\(ByteString
a,ByteString
b) -> ByteString
a ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> Int -> ByteString -> ByteString
Bchs.drop Int
2 ByteString
b) ((ByteString, ByteString) -> ByteString)
-> (ByteString, ByteString) -> ByteString
forall a b. (a -> b) -> a -> b
$ ByteString -> ByteString -> (ByteString, ByteString)
Bchs.breakSubstring ByteString
"\194\160" ByteString
x
            -- When a unicode string with the No-Break Space character is loaded, parsed
            -- and written by cassava (in encodeByNameWith) it is unexpectedly expanded:
            -- "MAMS-47224\194\160" becomes "MAMS-47224\195\130\194\160
            -- This was surprisingly hard to fix. We decided to remove No-Break Space chars
            -- entirely before parsing them.
            -- Here are some resources to see, which unicode characters are actually in a string:
            -- https://www.soscisurvey.de/tools/view-chars.php
            -- https://qaz.wtf/u/show.cgi
            -- https://onlineunicodetools.com/convert-unicode-to-bytes
            -- The following code removes the characters \194 and \160 independently.
            -- This breaks other unicode characters and therefore does not solve the problem
            --Bchs.filter (\y -> y /= '\194' && y /= '\160') x -- \160 is No-Break Space
            -- The following code allows to debug the issue more precisely
            --let !a = unsafePerformIO $ putStrLn $ show x
            --    b = ...
            --    !c = unsafePerformIO $ putStrLn $ show b
            --in b
        transNA :: Bchs.ByteString -> Maybe Bchs.ByteString
        transNA :: ByteString -> Maybe ByteString
transNA ByteString
""    = Maybe ByteString
forall a. Maybe a
Nothing
        transNA ByteString
"n/a" = Maybe ByteString
forall a. Maybe a
Nothing
        transNA ByteString
x     = ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ByteString
x

instance Csv.ToNamedRecord JannoRow where
    toNamedRecord :: JannoRow -> NamedRecord
toNamedRecord JannoRow
j = [(ByteString, ByteString)] -> NamedRecord
Csv.namedRecord [
          ByteString
"Poseidon_ID"                     ByteString -> String -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> String
jPoseidonID JannoRow
j
        , ByteString
"Genetic_Sex"                     ByteString -> JannoSex -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> JannoSex
jGeneticSex JannoRow
j
        , ByteString
"Group_Name"                      ByteString -> JannoStringList -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> JannoStringList
jGroupName JannoRow
j
        , ByteString
"Alternative_IDs"                 ByteString -> Maybe JannoStringList -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoStringList
jAlternativeIDs JannoRow
j
        , ByteString
"Relation_To"                     ByteString -> Maybe JannoStringList -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoStringList
jRelationTo JannoRow
j
        , ByteString
"Relation_Degree"                 ByteString
-> Maybe JannoRelationDegreeList -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoRelationDegreeList
jRelationDegree JannoRow
j
        , ByteString
"Relation_Type"                   ByteString -> Maybe JannoStringList -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoStringList
jRelationType JannoRow
j
        , ByteString
"Relation_Note"                   ByteString -> Maybe String -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe String
jRelationNote JannoRow
j
        , ByteString
"Collection_ID"                   ByteString -> Maybe String -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe String
jCollectionID JannoRow
j
        , ByteString
"Country"                         ByteString -> Maybe String -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe String
jCountry JannoRow
j
        , ByteString
"Country_ISO"                     ByteString -> Maybe JannoCountry -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoCountry
jCountryISO JannoRow
j
        , ByteString
"Location"                        ByteString -> Maybe String -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe String
jLocation JannoRow
j
        , ByteString
"Site"                            ByteString -> Maybe String -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe String
jSite JannoRow
j
        , ByteString
"Latitude"                        ByteString -> Maybe Latitude -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe Latitude
jLatitude JannoRow
j
        , ByteString
"Longitude"                       ByteString -> Maybe Longitude -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe Longitude
jLongitude JannoRow
j
        , ByteString
"Date_Type"                       ByteString -> Maybe JannoDateType -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoDateType
jDateType JannoRow
j
        , ByteString
"Date_C14_Labnr"                  ByteString -> Maybe JannoStringList -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoStringList
jDateC14Labnr JannoRow
j
        , ByteString
"Date_C14_Uncal_BP"               ByteString -> Maybe JannoIntList -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoIntList
jDateC14UncalBP JannoRow
j
        , ByteString
"Date_C14_Uncal_BP_Err"           ByteString -> Maybe JannoIntList -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoIntList
jDateC14UncalBPErr JannoRow
j
        , ByteString
"Date_BC_AD_Start"                ByteString -> Maybe BCADAge -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe BCADAge
jDateBCADStart JannoRow
j
        , ByteString
"Date_BC_AD_Median"               ByteString -> Maybe BCADAge -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe BCADAge
jDateBCADMedian JannoRow
j
        , ByteString
"Date_BC_AD_Stop"                 ByteString -> Maybe BCADAge -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe BCADAge
jDateBCADStop JannoRow
j
        , ByteString
"Date_Note"                       ByteString -> Maybe String -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe String
jDateNote JannoRow
j
        , ByteString
"MT_Haplogroup"                   ByteString -> Maybe String -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe String
jMTHaplogroup JannoRow
j
        , ByteString
"Y_Haplogroup"                    ByteString -> Maybe String -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe String
jYHaplogroup JannoRow
j
        , ByteString
"Source_Tissue"                   ByteString -> Maybe JannoStringList -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoStringList
jSourceTissue JannoRow
j
        , ByteString
"Nr_Libraries"                    ByteString -> Maybe Int -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe Int
jNrLibraries JannoRow
j
        , ByteString
"Library_Names"                   ByteString -> Maybe JannoStringList -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoStringList
jLibraryNames JannoRow
j
        , ByteString
"Capture_Type"                    ByteString
-> Maybe (JannoList JannoCaptureType) -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe (JannoList JannoCaptureType)
jCaptureType JannoRow
j
        , ByteString
"UDG"                             ByteString -> Maybe JannoUDG -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoUDG
jUDG JannoRow
j
        , ByteString
"Library_Built"                   ByteString -> Maybe JannoLibraryBuilt -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoLibraryBuilt
jLibraryBuilt JannoRow
j
        , ByteString
"Genotype_Ploidy"                 ByteString -> Maybe JannoGenotypePloidy -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoGenotypePloidy
jGenotypePloidy JannoRow
j
        , ByteString
"Data_Preparation_Pipeline_URL"   ByteString -> Maybe JURI -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JURI
jDataPreparationPipelineURL JannoRow
j
        , ByteString
"Endogenous"                      ByteString -> Maybe Percent -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe Percent
jEndogenous JannoRow
j
        , ByteString
"Nr_SNPs"                         ByteString -> Maybe Int -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe Int
jNrSNPs JannoRow
j
        , ByteString
"Coverage_on_Target_SNPs"         ByteString -> Maybe Double -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe Double
jCoverageOnTargets JannoRow
j
        , ByteString
"Damage"                          ByteString -> Maybe Percent -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe Percent
jDamage JannoRow
j
        , ByteString
"Contamination"                   ByteString -> Maybe JannoStringList -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoStringList
jContamination JannoRow
j
        , ByteString
"Contamination_Err"               ByteString -> Maybe JannoStringList -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoStringList
jContaminationErr JannoRow
j
        , ByteString
"Contamination_Meas"              ByteString -> Maybe JannoStringList -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoStringList
jContaminationMeas JannoRow
j
        , ByteString
"Contamination_Note"              ByteString -> Maybe String -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe String
jContaminationNote JannoRow
j
        , ByteString
"Genetic_Source_Accession_IDs"    ByteString
-> Maybe (JannoList AccessionID) -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe (JannoList AccessionID)
jGeneticSourceAccessionIDs JannoRow
j
        , ByteString
"Primary_Contact"                 ByteString -> Maybe String -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe String
jPrimaryContact JannoRow
j
        , ByteString
"Publication"                     ByteString -> Maybe JannoStringList -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoStringList
jPublication JannoRow
j
        , ByteString
"Note"                            ByteString -> Maybe String -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe String
jComments JannoRow
j
        , ByteString
"Keywords"                        ByteString -> Maybe JannoStringList -> (ByteString, ByteString)
forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
Csv..= JannoRow -> Maybe JannoStringList
jKeywords JannoRow
j
        -- beyond that add what is in the hashmap of additional columns
        ] NamedRecord -> NamedRecord -> NamedRecord
forall k v.
(Eq k, Hashable k) =>
HashMap k v -> HashMap k v -> HashMap k v
`HM.union` (CsvNamedRecord -> NamedRecord
getCsvNR (CsvNamedRecord -> NamedRecord) -> CsvNamedRecord -> NamedRecord
forall a b. (a -> b) -> a -> b
$ JannoRow -> CsvNamedRecord
jAdditionalColumns JannoRow
j)

-- | A function to create empty janno rows for a set of individuals
createMinimalJanno :: [EigenstratIndEntry] -> JannoRows
createMinimalJanno :: [EigenstratIndEntry] -> JannoRows
createMinimalJanno [] = JannoRows
forall a. Monoid a => a
mempty
createMinimalJanno [EigenstratIndEntry]
xs = [JannoRow] -> JannoRows
JannoRows ([JannoRow] -> JannoRows) -> [JannoRow] -> JannoRows
forall a b. (a -> b) -> a -> b
$ (EigenstratIndEntry -> JannoRow)
-> [EigenstratIndEntry] -> [JannoRow]
forall a b. (a -> b) -> [a] -> [b]
map EigenstratIndEntry -> JannoRow
createMinimalSample [EigenstratIndEntry]
xs

-- | A function to create an empty janno row for an individual
createMinimalSample :: EigenstratIndEntry -> JannoRow
createMinimalSample :: EigenstratIndEntry -> JannoRow
createMinimalSample (EigenstratIndEntry String
id_ Sex
sex String
pop) =
    JannoRow {
          jPoseidonID :: String
jPoseidonID                   = String
id_
        , jGeneticSex :: JannoSex
jGeneticSex                   = Sex -> JannoSex
JannoSex Sex
sex
        , jGroupName :: JannoStringList
jGroupName                    = JannoRowWarnings -> JannoStringList
forall a. [a] -> JannoList a
JannoList [String
pop]
        , jAlternativeIDs :: Maybe JannoStringList
jAlternativeIDs               = Maybe JannoStringList
forall a. Maybe a
Nothing
        , jRelationTo :: Maybe JannoStringList
jRelationTo                   = Maybe JannoStringList
forall a. Maybe a
Nothing
        , jRelationDegree :: Maybe JannoRelationDegreeList
jRelationDegree               = Maybe JannoRelationDegreeList
forall a. Maybe a
Nothing
        , jRelationType :: Maybe JannoStringList
jRelationType                 = Maybe JannoStringList
forall a. Maybe a
Nothing
        , jRelationNote :: Maybe String
jRelationNote                 = Maybe String
forall a. Maybe a
Nothing
        , jCollectionID :: Maybe String
jCollectionID                 = Maybe String
forall a. Maybe a
Nothing
        , jCountry :: Maybe String
jCountry                      = Maybe String
forall a. Maybe a
Nothing
        , jCountryISO :: Maybe JannoCountry
jCountryISO                   = Maybe JannoCountry
forall a. Maybe a
Nothing
        , jLocation :: Maybe String
jLocation                     = Maybe String
forall a. Maybe a
Nothing
        , jSite :: Maybe String
jSite                         = Maybe String
forall a. Maybe a
Nothing
        , jLatitude :: Maybe Latitude
jLatitude                     = Maybe Latitude
forall a. Maybe a
Nothing
        , jLongitude :: Maybe Longitude
jLongitude                    = Maybe Longitude
forall a. Maybe a
Nothing
        , jDateType :: Maybe JannoDateType
jDateType                     = Maybe JannoDateType
forall a. Maybe a
Nothing
        , jDateC14Labnr :: Maybe JannoStringList
jDateC14Labnr                 = Maybe JannoStringList
forall a. Maybe a
Nothing
        , jDateC14UncalBP :: Maybe JannoIntList
jDateC14UncalBP               = Maybe JannoIntList
forall a. Maybe a
Nothing
        , jDateC14UncalBPErr :: Maybe JannoIntList
jDateC14UncalBPErr            = Maybe JannoIntList
forall a. Maybe a
Nothing
        , jDateBCADStart :: Maybe BCADAge
jDateBCADStart                = Maybe BCADAge
forall a. Maybe a
Nothing
        , jDateBCADMedian :: Maybe BCADAge
jDateBCADMedian               = Maybe BCADAge
forall a. Maybe a
Nothing
        , jDateBCADStop :: Maybe BCADAge
jDateBCADStop                 = Maybe BCADAge
forall a. Maybe a
Nothing
        , jDateNote :: Maybe String
jDateNote                     = Maybe String
forall a. Maybe a
Nothing
        , jMTHaplogroup :: Maybe String
jMTHaplogroup                 = Maybe String
forall a. Maybe a
Nothing
        , jYHaplogroup :: Maybe String
jYHaplogroup                  = Maybe String
forall a. Maybe a
Nothing
        , jSourceTissue :: Maybe JannoStringList
jSourceTissue                 = Maybe JannoStringList
forall a. Maybe a
Nothing
        , jNrLibraries :: Maybe Int
jNrLibraries                  = Maybe Int
forall a. Maybe a
Nothing
        , jLibraryNames :: Maybe JannoStringList
jLibraryNames                 = Maybe JannoStringList
forall a. Maybe a
Nothing
        , jCaptureType :: Maybe (JannoList JannoCaptureType)
jCaptureType                  = Maybe (JannoList JannoCaptureType)
forall a. Maybe a
Nothing
        , jUDG :: Maybe JannoUDG
jUDG                          = Maybe JannoUDG
forall a. Maybe a
Nothing
        , jLibraryBuilt :: Maybe JannoLibraryBuilt
jLibraryBuilt                 = Maybe JannoLibraryBuilt
forall a. Maybe a
Nothing
        , jGenotypePloidy :: Maybe JannoGenotypePloidy
jGenotypePloidy               = Maybe JannoGenotypePloidy
forall a. Maybe a
Nothing
        , jDataPreparationPipelineURL :: Maybe JURI
jDataPreparationPipelineURL   = Maybe JURI
forall a. Maybe a
Nothing
        , jEndogenous :: Maybe Percent
jEndogenous                   = Maybe Percent
forall a. Maybe a
Nothing
        , jNrSNPs :: Maybe Int
jNrSNPs                       = Maybe Int
forall a. Maybe a
Nothing
        , jCoverageOnTargets :: Maybe Double
jCoverageOnTargets            = Maybe Double
forall a. Maybe a
Nothing
        , jDamage :: Maybe Percent
jDamage                       = Maybe Percent
forall a. Maybe a
Nothing
        , jContamination :: Maybe JannoStringList
jContamination                = Maybe JannoStringList
forall a. Maybe a
Nothing
        , jContaminationErr :: Maybe JannoStringList
jContaminationErr             = Maybe JannoStringList
forall a. Maybe a
Nothing
        , jContaminationMeas :: Maybe JannoStringList
jContaminationMeas            = Maybe JannoStringList
forall a. Maybe a
Nothing
        , jContaminationNote :: Maybe String
jContaminationNote            = Maybe String
forall a. Maybe a
Nothing
        , jGeneticSourceAccessionIDs :: Maybe (JannoList AccessionID)
jGeneticSourceAccessionIDs    = Maybe (JannoList AccessionID)
forall a. Maybe a
Nothing
        , jPrimaryContact :: Maybe String
jPrimaryContact               = Maybe String
forall a. Maybe a
Nothing
        , jPublication :: Maybe JannoStringList
jPublication                  = Maybe JannoStringList
forall a. Maybe a
Nothing
        , jComments :: Maybe String
jComments                     = Maybe String
forall a. Maybe a
Nothing
        , jKeywords :: Maybe JannoStringList
jKeywords                     = Maybe JannoStringList
forall a. Maybe a
Nothing
        -- The template should of course not have any additional columns
        , jAdditionalColumns :: CsvNamedRecord
jAdditionalColumns            = NamedRecord -> CsvNamedRecord
CsvNamedRecord (NamedRecord -> CsvNamedRecord) -> NamedRecord -> CsvNamedRecord
forall a b. (a -> b) -> a -> b
$ [(ByteString, ByteString)] -> NamedRecord
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList []
    }

-- Janno file writing

writeJannoFile :: FilePath -> JannoRows -> IO ()
writeJannoFile :: String -> JannoRows -> IO ()
writeJannoFile String
path (JannoRows [JannoRow]
rows) = do
    let jannoAsBytestring :: ByteString
jannoAsBytestring = EncodeOptions -> Header -> [JannoRow] -> ByteString
forall a.
ToNamedRecord a =>
EncodeOptions -> Header -> [a] -> ByteString
Csv.encodeByNameWith EncodeOptions
encodingOptions Header
makeHeaderWithAdditionalColumns [JannoRow]
rows
    let jannoAsBytestringwithNA :: ByteString
jannoAsBytestringwithNA = ByteString -> ByteString
explicitNA ByteString
jannoAsBytestring
    String -> ByteString -> IO ()
Bch.writeFile String
path ByteString
jannoAsBytestringwithNA
    where
        makeHeaderWithAdditionalColumns :: Csv.Header
        makeHeaderWithAdditionalColumns :: Header
makeHeaderWithAdditionalColumns =
            [ByteString] -> Header
forall a. [a] -> Vector a
V.fromList ([ByteString] -> Header) -> [ByteString] -> Header
forall a b. (a -> b) -> a -> b
$ [ByteString]
jannoHeader [ByteString] -> [ByteString] -> [ByteString]
forall a. [a] -> [a] -> [a]
++ [ByteString] -> [ByteString]
forall a. Ord a => [a] -> [a]
sort (NamedRecord -> [ByteString]
forall k v. HashMap k v -> [k]
HM.keys ([NamedRecord] -> NamedRecord
forall k v. (Eq k, Hashable k) => [HashMap k v] -> HashMap k v
HM.unions ((JannoRow -> NamedRecord) -> [JannoRow] -> [NamedRecord]
forall a b. (a -> b) -> [a] -> [b]
map (CsvNamedRecord -> NamedRecord
getCsvNR (CsvNamedRecord -> NamedRecord)
-> (JannoRow -> CsvNamedRecord) -> JannoRow -> NamedRecord
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JannoRow -> CsvNamedRecord
jAdditionalColumns) [JannoRow]
rows)))

encodingOptions :: Csv.EncodeOptions
encodingOptions :: EncodeOptions
encodingOptions = EncodeOptions
Csv.defaultEncodeOptions {
      encDelimiter :: Word8
Csv.encDelimiter = Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Char -> Int
ord Char
'\t')
    , encUseCrLf :: Bool
Csv.encUseCrLf = Bool
False
    , encIncludeHeader :: Bool
Csv.encIncludeHeader = Bool
True
    , encQuoting :: Quoting
Csv.encQuoting = Quoting
Csv.QuoteMinimal
}

-- | A function to load one janno file
readJannoFile :: FilePath -> PoseidonIO JannoRows
readJannoFile :: String -> PoseidonIO JannoRows
readJannoFile String
jannoPath = do
    String -> PoseidonIO ()
logDebug (String -> PoseidonIO ()) -> String -> PoseidonIO ()
forall a b. (a -> b) -> a -> b
$ String
"Reading: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
jannoPath
    ByteString
jannoFile <- IO ByteString -> ReaderT Env IO ByteString
forall a. IO a -> ReaderT Env IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> ReaderT Env IO ByteString)
-> IO ByteString -> ReaderT Env IO ByteString
forall a b. (a -> b) -> a -> b
$ String -> IO ByteString
Bch.readFile String
jannoPath
    let jannoFileRows :: [ByteString]
jannoFileRows = ByteString -> [ByteString]
Bch.lines ByteString
jannoFile
    Bool -> PoseidonIO () -> PoseidonIO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when ([ByteString] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [ByteString]
jannoFileRows Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
2) (PoseidonIO () -> PoseidonIO ()) -> PoseidonIO () -> PoseidonIO ()
forall a b. (a -> b) -> a -> b
$ IO () -> PoseidonIO ()
forall a. IO a -> ReaderT Env IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> PoseidonIO ()) -> IO () -> PoseidonIO ()
forall a b. (a -> b) -> a -> b
$ PoseidonException -> IO ()
forall e a. Exception e => e -> IO a
throwIO (PoseidonException -> IO ()) -> PoseidonException -> IO ()
forall a b. (a -> b) -> a -> b
$ String -> String -> PoseidonException
PoseidonFileConsistencyException String
jannoPath String
"File has less than two lines"
    String -> PoseidonIO ()
logDebug (String -> PoseidonIO ()) -> String -> PoseidonIO ()
forall a b. (a -> b) -> a -> b
$ Int -> String
forall a. Show a => a -> String
show ([ByteString] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [ByteString]
jannoFileRows Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" samples in this file"
    -- tupel with row number and row bytestring
    let jannoFileRowsWithNumber :: [(Int, ByteString)]
jannoFileRowsWithNumber = [Int] -> [ByteString] -> [(Int, ByteString)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
1..([ByteString] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [ByteString]
jannoFileRows)] [ByteString]
jannoFileRows
    -- filter out empty lines
        jannoFileRowsWithNumberFiltered :: [(Int, ByteString)]
jannoFileRowsWithNumberFiltered = ((Int, ByteString) -> Bool)
-> [(Int, ByteString)] -> [(Int, ByteString)]
forall a. (a -> Bool) -> [a] -> [a]
filter (\(Int
_, ByteString
y) -> ByteString
y ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
/= ByteString
Bch.empty) [(Int, ByteString)]
jannoFileRowsWithNumber
    -- create header + individual line combination
        headerOnlyPotentiallyWithQuotes :: ByteString
headerOnlyPotentiallyWithQuotes = (Int, ByteString) -> ByteString
forall a b. (a, b) -> b
snd ((Int, ByteString) -> ByteString)
-> (Int, ByteString) -> ByteString
forall a b. (a -> b) -> a -> b
$ [(Int, ByteString)] -> (Int, ByteString)
forall a. HasCallStack => [a] -> a
head [(Int, ByteString)]
jannoFileRowsWithNumberFiltered
        -- removing the quotes like this might cause issues in edge cases
        headerOnly :: ByteString
headerOnly = (Char -> Bool) -> ByteString -> ByteString
Bch.filter (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'"') ByteString
headerOnlyPotentiallyWithQuotes
        rowsOnly :: [(Int, ByteString)]
rowsOnly = [(Int, ByteString)] -> [(Int, ByteString)]
forall a. HasCallStack => [a] -> [a]
tail [(Int, ByteString)]
jannoFileRowsWithNumberFiltered
        jannoFileRowsWithHeader :: [(Int, ByteString)]
jannoFileRowsWithHeader = ((Int, ByteString) -> (Int, ByteString))
-> [(Int, ByteString)] -> [(Int, ByteString)]
forall a b. (a -> b) -> [a] -> [b]
map ((ByteString -> ByteString)
-> (Int, ByteString) -> (Int, ByteString)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second (\ByteString
x -> ByteString
headerOnly ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> ByteString
"\n" ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> ByteString
x)) [(Int, ByteString)]
rowsOnly
    -- report missing or additional columns
    let jannoColNames :: [ByteString]
jannoColNames = (ByteString -> ByteString) -> [ByteString] -> [ByteString]
forall a b. (a -> b) -> [a] -> [b]
map ByteString -> ByteString
Bch.toStrict (Char -> ByteString -> [ByteString]
Bch.split Char
'\t' ByteString
headerOnly)
        missing_columns :: JannoRowWarnings
missing_columns = (ByteString -> String) -> [ByteString] -> JannoRowWarnings
forall a b. (a -> b) -> [a] -> [b]
map ByteString -> String
Bchs.unpack ([ByteString] -> JannoRowWarnings)
-> [ByteString] -> JannoRowWarnings
forall a b. (a -> b) -> a -> b
$ [ByteString]
jannoHeader [ByteString] -> [ByteString] -> [ByteString]
forall a. Eq a => [a] -> [a] -> [a]
\\ [ByteString]
jannoColNames
        additional_columns :: JannoRowWarnings
additional_columns = (ByteString -> String) -> [ByteString] -> JannoRowWarnings
forall a b. (a -> b) -> [a] -> [b]
map ByteString -> String
Bchs.unpack ([ByteString] -> JannoRowWarnings)
-> [ByteString] -> JannoRowWarnings
forall a b. (a -> b) -> a -> b
$ [ByteString]
jannoColNames [ByteString] -> [ByteString] -> [ByteString]
forall a. Eq a => [a] -> [a] -> [a]
\\ [ByteString]
jannoHeader
    --unless (null missing_columns) $ do
    --    logDebug ("Missing standard columns: " ++ intercalate ", " missing_columns)
    Bool -> PoseidonIO () -> PoseidonIO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (JannoRowWarnings -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null JannoRowWarnings
additional_columns) (PoseidonIO () -> PoseidonIO ()) -> PoseidonIO () -> PoseidonIO ()
forall a b. (a -> b) -> a -> b
$ do
        String -> PoseidonIO ()
logDebug (String
"Additional columns: " String -> ShowS
forall a. [a] -> [a] -> [a]
++
        -- for each additional column a standard column is suggested: "Countro (Country?)"
            String -> JannoRowWarnings -> String
forall a. [a] -> [[a]] -> [a]
intercalate String
", " ((String -> ShowS)
-> JannoRowWarnings -> JannoRowWarnings -> JannoRowWarnings
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (\String
x String
y -> String
x String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" (" String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
y String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"?)")
            JannoRowWarnings
additional_columns (JannoRowWarnings -> JannoRowWarnings -> JannoRowWarnings
findSimilarNames JannoRowWarnings
missing_columns JannoRowWarnings
additional_columns)))
    -- load janno by rows
    [Either PoseidonException JannoRow]
jannoRepresentation <- ((Int, ByteString)
 -> ReaderT Env IO (Either PoseidonException JannoRow))
-> [(Int, ByteString)]
-> ReaderT Env IO [Either PoseidonException JannoRow]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (String
-> (Int, ByteString)
-> ReaderT Env IO (Either PoseidonException JannoRow)
readJannoFileRow String
jannoPath) [(Int, ByteString)]
jannoFileRowsWithHeader
    -- error case management
    if Bool -> Bool
not ([PoseidonException] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([Either PoseidonException JannoRow] -> [PoseidonException]
forall a b. [Either a b] -> [a]
lefts [Either PoseidonException JannoRow]
jannoRepresentation))
    then do
        (PoseidonException -> PoseidonIO ())
-> [PoseidonException] -> PoseidonIO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (String -> PoseidonIO ()
logError (String -> PoseidonIO ())
-> (PoseidonException -> String)
-> PoseidonException
-> PoseidonIO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PoseidonException -> String
renderPoseidonException) ([PoseidonException] -> PoseidonIO ())
-> [PoseidonException] -> PoseidonIO ()
forall a b. (a -> b) -> a -> b
$ Int -> [PoseidonException] -> [PoseidonException]
forall a. Int -> [a] -> [a]
take Int
5 ([PoseidonException] -> [PoseidonException])
-> [PoseidonException] -> [PoseidonException]
forall a b. (a -> b) -> a -> b
$ [Either PoseidonException JannoRow] -> [PoseidonException]
forall a b. [Either a b] -> [a]
lefts [Either PoseidonException JannoRow]
jannoRepresentation
        IO JannoRows -> PoseidonIO JannoRows
forall a. IO a -> ReaderT Env IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO JannoRows -> PoseidonIO JannoRows)
-> IO JannoRows -> PoseidonIO JannoRows
forall a b. (a -> b) -> a -> b
$ PoseidonException -> IO JannoRows
forall e a. Exception e => e -> IO a
throwIO (PoseidonException -> IO JannoRows)
-> PoseidonException -> IO JannoRows
forall a b. (a -> b) -> a -> b
$ String -> String -> PoseidonException
PoseidonFileConsistencyException String
jannoPath String
"Broken lines."
    else do
        let consistentJanno :: Either PoseidonException JannoRows
consistentJanno = String -> JannoRows -> Either PoseidonException JannoRows
checkJannoConsistency String
jannoPath (JannoRows -> Either PoseidonException JannoRows)
-> JannoRows -> Either PoseidonException JannoRows
forall a b. (a -> b) -> a -> b
$ [JannoRow] -> JannoRows
JannoRows ([JannoRow] -> JannoRows) -> [JannoRow] -> JannoRows
forall a b. (a -> b) -> a -> b
$ [Either PoseidonException JannoRow] -> [JannoRow]
forall a b. [Either a b] -> [b]
rights [Either PoseidonException JannoRow]
jannoRepresentation
        case Either PoseidonException JannoRows
consistentJanno of
            Left PoseidonException
e -> do IO JannoRows -> PoseidonIO JannoRows
forall a. IO a -> ReaderT Env IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO JannoRows -> PoseidonIO JannoRows)
-> IO JannoRows -> PoseidonIO JannoRows
forall a b. (a -> b) -> a -> b
$ PoseidonException -> IO JannoRows
forall e a. Exception e => e -> IO a
throwIO PoseidonException
e
            Right JannoRows
x -> do
                -- putStrLn ""
                -- putStrLn $ show $ map jSourceTissue x
                -- putStrLn $ show $ map jLongitude x
                -- putStrLn $ show $ map jUDG x
                JannoRows -> PoseidonIO JannoRows
forall a. a -> ReaderT Env IO a
forall (m :: * -> *) a. Monad m => a -> m a
return JannoRows
x

findSimilarNames :: [String] -> [String] -> [String]
findSimilarNames :: JannoRowWarnings -> JannoRowWarnings -> JannoRowWarnings
findSimilarNames JannoRowWarnings
reference = ShowS -> JannoRowWarnings -> JannoRowWarnings
forall a b. (a -> b) -> [a] -> [b]
map (JannoRowWarnings -> ShowS
findSimilar JannoRowWarnings
reference)
    where
        findSimilar ::  [String] -> String -> String
        findSimilar :: JannoRowWarnings -> ShowS
findSimilar [] String
_  = []
        findSimilar JannoRowWarnings
ref String
x =
            let dists :: [Int]
dists = (String -> Int) -> JannoRowWarnings -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map (\String
y -> String
x String -> String -> Int
forall a. Eq a => [a] -> [a] -> Int
`editDistance` String
y) JannoRowWarnings
ref
            in JannoRowWarnings
ref JannoRowWarnings -> Int -> String
forall a. HasCallStack => [a] -> Int -> a
!! Maybe Int -> Int
forall a. HasCallStack => Maybe a -> a
fromJust (Int -> [Int] -> Maybe Int
forall a. Eq a => a -> [a] -> Maybe Int
elemIndex ([Int] -> Int
forall a. Ord a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
minimum [Int]
dists) [Int]
dists)

-- | A function to load one row of a janno file
readJannoFileRow :: FilePath -> (Int, Bch.ByteString) -> PoseidonIO (Either PoseidonException JannoRow)
readJannoFileRow :: String
-> (Int, ByteString)
-> ReaderT Env IO (Either PoseidonException JannoRow)
readJannoFileRow String
jannoPath (Int
lineNumber, ByteString
row) = do
    let decoded :: Either String (Header, Vector JannoRow)
decoded = DecodeOptions
-> ByteString -> Either String (Header, Vector JannoRow)
forall a.
FromNamedRecord a =>
DecodeOptions -> ByteString -> Either String (Header, Vector a)
Csv.decodeByNameWith DecodeOptions
decodingOptions ByteString
row
        simplifiedDecoded :: Either String JannoRow
simplifiedDecoded = (\(Header
_,Vector JannoRow
rs) -> Vector JannoRow -> JannoRow
forall a. Vector a -> a
V.head Vector JannoRow
rs) ((Header, Vector JannoRow) -> JannoRow)
-> Either String (Header, Vector JannoRow)
-> Either String JannoRow
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Either String (Header, Vector JannoRow)
decoded
    case Either String JannoRow
simplifiedDecoded of
        Left String
e -> do
            let betterError :: String
betterError = case Parsec String () CsvParseError
-> String -> String -> Either ParseError CsvParseError
forall s t a.
Stream s Identity t =>
Parsec s () a -> String -> s -> Either ParseError a
P.parse Parsec String () CsvParseError
parseCsvParseError String
"" String
e of
                    Left ParseError
_       -> ShowS
removeUselessSuffix String
e
                    Right CsvParseError
result -> CsvParseError -> String
renderCsvParseError CsvParseError
result
            Either PoseidonException JannoRow
-> ReaderT Env IO (Either PoseidonException JannoRow)
forall a. a -> ReaderT Env IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either PoseidonException JannoRow
 -> ReaderT Env IO (Either PoseidonException JannoRow))
-> Either PoseidonException JannoRow
-> ReaderT Env IO (Either PoseidonException JannoRow)
forall a b. (a -> b) -> a -> b
$ PoseidonException -> Either PoseidonException JannoRow
forall a b. a -> Either a b
Left (PoseidonException -> Either PoseidonException JannoRow)
-> PoseidonException -> Either PoseidonException JannoRow
forall a b. (a -> b) -> a -> b
$ String -> String -> String -> PoseidonException
PoseidonFileRowException String
jannoPath (Int -> String
forall a. Show a => a -> String
show Int
lineNumber) String
betterError
        Right JannoRow
jannoRow -> do
            let (Either String JannoRow
errOrJannoRow, JannoRowWarnings
warnings) = Writer JannoRowWarnings (Either String JannoRow)
-> (Either String JannoRow, JannoRowWarnings)
forall w a. Writer w a -> (a, w)
W.runWriter (ExceptT String (Writer JannoRowWarnings) JannoRow
-> Writer JannoRowWarnings (Either String JannoRow)
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
E.runExceptT (JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow
checkJannoRowConsistency JannoRow
jannoRow))
            (String -> PoseidonIO ()) -> JannoRowWarnings -> PoseidonIO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (String -> PoseidonIO ()
logWarning (String -> PoseidonIO ()) -> ShowS -> String -> PoseidonIO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
renderWarning) JannoRowWarnings
warnings
            case Either String JannoRow
errOrJannoRow of
                Left String
e  -> Either PoseidonException JannoRow
-> ReaderT Env IO (Either PoseidonException JannoRow)
forall a. a -> ReaderT Env IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either PoseidonException JannoRow
 -> ReaderT Env IO (Either PoseidonException JannoRow))
-> Either PoseidonException JannoRow
-> ReaderT Env IO (Either PoseidonException JannoRow)
forall a b. (a -> b) -> a -> b
$ PoseidonException -> Either PoseidonException JannoRow
forall a b. a -> Either a b
Left (PoseidonException -> Either PoseidonException JannoRow)
-> PoseidonException -> Either PoseidonException JannoRow
forall a b. (a -> b) -> a -> b
$ String -> String -> String -> PoseidonException
PoseidonFileRowException String
jannoPath String
renderLocation String
e
                Right JannoRow
r -> Either PoseidonException JannoRow
-> ReaderT Env IO (Either PoseidonException JannoRow)
forall a. a -> ReaderT Env IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either PoseidonException JannoRow
 -> ReaderT Env IO (Either PoseidonException JannoRow))
-> Either PoseidonException JannoRow
-> ReaderT Env IO (Either PoseidonException JannoRow)
forall a b. (a -> b) -> a -> b
$ JannoRow -> Either PoseidonException JannoRow
forall a b. b -> Either a b
Right JannoRow
r
            where
                renderWarning :: String -> String
                renderWarning :: ShowS
renderWarning String
e = String
"Issue in " String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
jannoPath String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" " String -> ShowS
forall a. [a] -> [a] -> [a]
++
                                  String
"in line " String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
renderLocation String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
": " String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
e
                renderLocation :: String
                renderLocation :: String
renderLocation =  Int -> String
forall a. Show a => a -> String
show Int
lineNumber String -> ShowS
forall a. [a] -> [a] -> [a]
++
                                  String
" (Poseidon_ID: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ JannoRow -> String
jPoseidonID JannoRow
jannoRow String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"

decodingOptions :: Csv.DecodeOptions
decodingOptions :: DecodeOptions
decodingOptions = DecodeOptions
Csv.defaultDecodeOptions {
    decDelimiter :: Word8
Csv.decDelimiter = Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Char -> Int
ord Char
'\t')
}

removeUselessSuffix :: String -> String
removeUselessSuffix :: ShowS
removeUselessSuffix = Text -> String
unpack (Text -> String) -> (String -> Text) -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => Text -> Text -> Text -> Text
Text -> Text -> Text -> Text
replace Text
" at \"\"" Text
"" (Text -> Text) -> (String -> Text) -> String -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
pack

-- reformat the parser error
-- from: parse error (Failed reading: conversion error: expected Int, got "430;" (incomplete field parse, leftover: [59]))
-- to:   parse error in one column (expected data type: Int, broken value: "430;", problematic characters: ";")

data CsvParseError = CsvParseError {
      CsvParseError -> String
_expected :: String
    , CsvParseError -> String
_actual   :: String
    , CsvParseError -> String
_leftover :: String
} deriving Int -> CsvParseError -> ShowS
[CsvParseError] -> ShowS
CsvParseError -> String
(Int -> CsvParseError -> ShowS)
-> (CsvParseError -> String)
-> ([CsvParseError] -> ShowS)
-> Show CsvParseError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CsvParseError -> ShowS
showsPrec :: Int -> CsvParseError -> ShowS
$cshow :: CsvParseError -> String
show :: CsvParseError -> String
$cshowList :: [CsvParseError] -> ShowS
showList :: [CsvParseError] -> ShowS
Show

parseCsvParseError :: P.Parser CsvParseError
parseCsvParseError :: Parsec String () CsvParseError
parseCsvParseError = do
    String
_ <- String -> ParsecT String () Identity String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"parse error (Failed reading: conversion error: expected "
    String
expected <- ParsecT String () Identity Char
-> ParsecT String () Identity String
-> ParsecT String () Identity String
forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
P.manyTill ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.anyChar (ParsecT String () Identity String
-> ParsecT String () Identity String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
P.try (String -> ParsecT String () Identity String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
", got "))
    String
actual <- ParsecT String () Identity Char
-> ParsecT String () Identity String
-> ParsecT String () Identity String
forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
P.manyTill ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.anyChar (ParsecT String () Identity String
-> ParsecT String () Identity String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
P.try (String -> ParsecT String () Identity String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
" (incomplete field parse, leftover: ["))
    [Int]
leftoverList <- ParsecT String () Identity Int
-> ParsecT String () Identity Char
-> ParsecT String () Identity [Int]
forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
P.sepBy (String -> Int
forall a. Read a => String -> a
read (String -> Int)
-> ParsecT String () Identity String
-> ParsecT String () Identity Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Char
-> ParsecT String () Identity String
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
P.many1 ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.digit) (Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
',')
    Char
_ <- Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
']'
    String
_ <- ParsecT String () Identity Char
-> ParsecT String () Identity String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
P.many ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.anyChar
    CsvParseError -> Parsec String () CsvParseError
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (CsvParseError -> Parsec String () CsvParseError)
-> CsvParseError -> Parsec String () CsvParseError
forall a b. (a -> b) -> a -> b
$ String -> String -> String -> CsvParseError
CsvParseError String
expected String
actual ((Int -> Char) -> [Int] -> String
forall a b. (a -> b) -> [a] -> [b]
map Int -> Char
chr [Int]
leftoverList)

renderCsvParseError :: CsvParseError -> String
renderCsvParseError :: CsvParseError -> String
renderCsvParseError (CsvParseError String
expected String
actual String
leftover) =
    String
"parse error in one column (" String -> ShowS
forall a. [a] -> [a] -> [a]
++
    String
"expected data type: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
expected String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
", " String -> ShowS
forall a. [a] -> [a] -> [a]
++
    String
"broken value: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
actual String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
", " String -> ShowS
forall a. [a] -> [a] -> [a]
++
    String
"problematic characters: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show String
leftover String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"

-- | A helper functions to replace empty bytestrings values in janno files with explicit "n/a"
explicitNA :: Bch.ByteString -> Bch.ByteString
explicitNA :: ByteString -> ByteString
explicitNA = ByteString -> ByteString -> ByteString -> ByteString
replaceInJannoBytestring ByteString
Bch.empty ByteString
"n/a"

replaceInJannoBytestring :: Bch.ByteString -> Bch.ByteString -> Bch.ByteString -> Bch.ByteString
replaceInJannoBytestring :: ByteString -> ByteString -> ByteString -> ByteString
replaceInJannoBytestring ByteString
from ByteString
to ByteString
tsv =
    let tsvRows :: [ByteString]
tsvRows = ByteString -> [ByteString]
Bch.lines ByteString
tsv
        tsvCells :: [[ByteString]]
tsvCells = (ByteString -> [ByteString]) -> [ByteString] -> [[ByteString]]
forall a b. (a -> b) -> [a] -> [b]
map ((Char -> Bool) -> ByteString -> [ByteString]
Bch.splitWith (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==Char
'\t')) [ByteString]
tsvRows
        tsvCellsUpdated :: [[ByteString]]
tsvCellsUpdated = ([ByteString] -> [ByteString]) -> [[ByteString]] -> [[ByteString]]
forall a b. (a -> b) -> [a] -> [b]
map ((ByteString -> ByteString) -> [ByteString] -> [ByteString]
forall a b. (a -> b) -> [a] -> [b]
map (\ByteString
y -> if ByteString
y ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString
from Bool -> Bool -> Bool
|| ByteString
y ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString -> ByteString -> ByteString
Bch.append ByteString
from ByteString
"\r" then ByteString
to else ByteString
y)) [[ByteString]]
tsvCells
        tsvRowsUpdated :: [ByteString]
tsvRowsUpdated = ([ByteString] -> ByteString) -> [[ByteString]] -> [ByteString]
forall a b. (a -> b) -> [a] -> [b]
map (ByteString -> [ByteString] -> ByteString
Bch.intercalate (String -> ByteString
Bch.pack String
"\t")) [[ByteString]]
tsvCellsUpdated
   in [ByteString] -> ByteString
Bch.unlines [ByteString]
tsvRowsUpdated

-- Global janno consistency checks

checkJannoConsistency :: FilePath -> JannoRows -> Either PoseidonException JannoRows
checkJannoConsistency :: String -> JannoRows -> Either PoseidonException JannoRows
checkJannoConsistency String
jannoPath JannoRows
xs
    | Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ JannoRows -> Bool
checkIndividualUnique JannoRows
xs = PoseidonException -> Either PoseidonException JannoRows
forall a b. a -> Either a b
Left (PoseidonException -> Either PoseidonException JannoRows)
-> PoseidonException -> Either PoseidonException JannoRows
forall a b. (a -> b) -> a -> b
$ String -> String -> PoseidonException
PoseidonFileConsistencyException String
jannoPath
        String
"The Poseidon_IDs are not unique"
    | Bool
otherwise = JannoRows -> Either PoseidonException JannoRows
forall a b. b -> Either a b
Right JannoRows
xs

checkIndividualUnique :: JannoRows -> Bool
checkIndividualUnique :: JannoRows -> Bool
checkIndividualUnique (JannoRows [JannoRow]
rows) = [JannoRow] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [JannoRow]
rows Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== JannoRowWarnings -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (JannoRowWarnings -> JannoRowWarnings
forall a. Eq a => [a] -> [a]
nub (JannoRowWarnings -> JannoRowWarnings)
-> JannoRowWarnings -> JannoRowWarnings
forall a b. (a -> b) -> a -> b
$ (JannoRow -> String) -> [JannoRow] -> JannoRowWarnings
forall a b. (a -> b) -> [a] -> [b]
map JannoRow -> String
jPoseidonID [JannoRow]
rows)

-- Row-wise janno consistency checks

type JannoRowWarnings = [String]
type JannoRowLog = E.ExceptT String (W.Writer JannoRowWarnings)

checkJannoRowConsistency :: JannoRow -> JannoRowLog JannoRow
checkJannoRowConsistency :: JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow
checkJannoRowConsistency JannoRow
x =
    JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow
forall a. a -> ExceptT String (Writer JannoRowWarnings) a
forall (m :: * -> *) a. Monad m => a -> m a
return JannoRow
x
    ExceptT String (Writer JannoRowWarnings) JannoRow
-> (JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow)
-> ExceptT String (Writer JannoRowWarnings) JannoRow
forall a b.
ExceptT String (Writer JannoRowWarnings) a
-> (a -> ExceptT String (Writer JannoRowWarnings) b)
-> ExceptT String (Writer JannoRowWarnings) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow
checkMandatoryStringNotEmpty
    ExceptT String (Writer JannoRowWarnings) JannoRow
-> (JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow)
-> ExceptT String (Writer JannoRowWarnings) JannoRow
forall a b.
ExceptT String (Writer JannoRowWarnings) a
-> (a -> ExceptT String (Writer JannoRowWarnings) b)
-> ExceptT String (Writer JannoRowWarnings) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow
checkC14ColsConsistent
    ExceptT String (Writer JannoRowWarnings) JannoRow
-> (JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow)
-> ExceptT String (Writer JannoRowWarnings) JannoRow
forall a b.
ExceptT String (Writer JannoRowWarnings) a
-> (a -> ExceptT String (Writer JannoRowWarnings) b)
-> ExceptT String (Writer JannoRowWarnings) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow
checkContamColsConsistent
    ExceptT String (Writer JannoRowWarnings) JannoRow
-> (JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow)
-> ExceptT String (Writer JannoRowWarnings) JannoRow
forall a b.
ExceptT String (Writer JannoRowWarnings) a
-> (a -> ExceptT String (Writer JannoRowWarnings) b)
-> ExceptT String (Writer JannoRowWarnings) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow
checkRelationColsConsistent

checkMandatoryStringNotEmpty :: JannoRow -> JannoRowLog JannoRow
checkMandatoryStringNotEmpty :: JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow
checkMandatoryStringNotEmpty JannoRow
x =
    let notEmpty :: Bool
notEmpty = (Bool -> Bool
not (Bool -> Bool) -> (JannoRow -> Bool) -> JannoRow -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (String -> Bool) -> (JannoRow -> String) -> JannoRow -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JannoRow -> String
jPoseidonID (JannoRow -> Bool) -> JannoRow -> Bool
forall a b. (a -> b) -> a -> b
$ JannoRow
x) Bool -> Bool -> Bool
&&
                   (Bool -> Bool
not (Bool -> Bool) -> (JannoRow -> Bool) -> JannoRow -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JannoRowWarnings -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (JannoRowWarnings -> Bool)
-> (JannoRow -> JannoRowWarnings) -> JannoRow -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JannoStringList -> JannoRowWarnings
forall a. JannoList a -> [a]
getJannoList (JannoStringList -> JannoRowWarnings)
-> (JannoRow -> JannoStringList) -> JannoRow -> JannoRowWarnings
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JannoRow -> JannoStringList
jGroupName (JannoRow -> Bool) -> JannoRow -> Bool
forall a b. (a -> b) -> a -> b
$ JannoRow
x) Bool -> Bool -> Bool
&&
                   (Bool -> Bool
not (Bool -> Bool) -> (JannoRow -> Bool) -> JannoRow -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (String -> Bool) -> (JannoRow -> String) -> JannoRow -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JannoRowWarnings -> String
forall a. HasCallStack => [a] -> a
head (JannoRowWarnings -> String)
-> (JannoRow -> JannoRowWarnings) -> JannoRow -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JannoStringList -> JannoRowWarnings
forall a. JannoList a -> [a]
getJannoList (JannoStringList -> JannoRowWarnings)
-> (JannoRow -> JannoStringList) -> JannoRow -> JannoRowWarnings
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JannoRow -> JannoStringList
jGroupName (JannoRow -> Bool) -> JannoRow -> Bool
forall a b. (a -> b) -> a -> b
$ JannoRow
x)
    in case Bool
notEmpty of
        Bool
False -> String -> ExceptT String (Writer JannoRowWarnings) JannoRow
forall a. String -> ExceptT String (Writer JannoRowWarnings) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
E.throwError String
"Poseidon_ID or Group_Name are empty"
        Bool
True  -> JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow
forall a. a -> ExceptT String (Writer JannoRowWarnings) a
forall (m :: * -> *) a. Monad m => a -> m a
return JannoRow
x

getCellLength :: Maybe (JannoList a) -> Int
getCellLength :: forall a. Maybe (JannoList a) -> Int
getCellLength = Int -> (JannoList a -> Int) -> Maybe (JannoList a) -> Int
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Int
0 ([a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([a] -> Int) -> (JannoList a -> [a]) -> JannoList a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JannoList a -> [a]
forall a. JannoList a -> [a]
getJannoList)

allEqual :: Eq a => [a] -> Bool
allEqual :: forall a. Eq a => [a] -> Bool
allEqual [] = Bool
True
allEqual [a]
x  = [a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([a] -> [a]
forall a. Eq a => [a] -> [a]
nub [a]
x) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1

checkC14ColsConsistent :: JannoRow -> JannoRowLog JannoRow
checkC14ColsConsistent :: JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow
checkC14ColsConsistent JannoRow
x =
    let isTypeC14 :: Bool
isTypeC14        = JannoRow -> Maybe JannoDateType
jDateType JannoRow
x Maybe JannoDateType -> Maybe JannoDateType -> Bool
forall a. Eq a => a -> a -> Bool
== JannoDateType -> Maybe JannoDateType
forall a. a -> Maybe a
Just JannoDateType
C14
        lLabnr :: Int
lLabnr           = Maybe JannoStringList -> Int
forall a. Maybe (JannoList a) -> Int
getCellLength (Maybe JannoStringList -> Int) -> Maybe JannoStringList -> Int
forall a b. (a -> b) -> a -> b
$ JannoRow -> Maybe JannoStringList
jDateC14Labnr JannoRow
x
        lUncalBP :: Int
lUncalBP         = Maybe JannoIntList -> Int
forall a. Maybe (JannoList a) -> Int
getCellLength (Maybe JannoIntList -> Int) -> Maybe JannoIntList -> Int
forall a b. (a -> b) -> a -> b
$ JannoRow -> Maybe JannoIntList
jDateC14UncalBP JannoRow
x
        lUncalBPErr :: Int
lUncalBPErr      = Maybe JannoIntList -> Int
forall a. Maybe (JannoList a) -> Int
getCellLength (Maybe JannoIntList -> Int) -> Maybe JannoIntList -> Int
forall a b. (a -> b) -> a -> b
$ JannoRow -> Maybe JannoIntList
jDateC14UncalBPErr JannoRow
x
        anyMainColFilled :: Bool
anyMainColFilled = Int
lUncalBP Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0 Bool -> Bool -> Bool
|| Int
lUncalBPErr Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0
        anyMainColEmpty :: Bool
anyMainColEmpty  = Int
lUncalBP Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 Bool -> Bool -> Bool
|| Int
lUncalBPErr Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0
        allSameLength :: Bool
allSameLength    = [Int] -> Bool
forall a. Eq a => [a] -> Bool
allEqual [Int
lLabnr, Int
lUncalBP, Int
lUncalBPErr] Bool -> Bool -> Bool
||
                          (Int
lLabnr Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 Bool -> Bool -> Bool
&& Int
lUncalBP Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
lUncalBPErr)
    in case (Bool
isTypeC14, Bool
anyMainColFilled, Bool
anyMainColEmpty, Bool
allSameLength) of
        (Bool
False, Bool
False, Bool
_, Bool
_ )   -> JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow
forall a. a -> ExceptT String (Writer JannoRowWarnings) a
forall (m :: * -> *) a. Monad m => a -> m a
return JannoRow
x
        (Bool
False, Bool
True, Bool
_, Bool
_ )    -> String -> ExceptT String (Writer JannoRowWarnings) JannoRow
forall a. String -> ExceptT String (Writer JannoRowWarnings) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
E.throwError String
"Date_Type is not \"C14\", but either \
                                         \Date_C14_Uncal_BP or Date_C14_Uncal_BP_Err are not empty"
        (Bool
True, Bool
_, Bool
False, Bool
False) -> String -> ExceptT String (Writer JannoRowWarnings) JannoRow
forall a. String -> ExceptT String (Writer JannoRowWarnings) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
E.throwError String
"Date_C14_Labnr, Date_C14_Uncal_BP and Date_C14_Uncal_BP_Err \
                                         \do not have the same lengths"
        (Bool
True, Bool
_, Bool
False, Bool
True ) -> JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow
forall a. a -> ExceptT String (Writer JannoRowWarnings) a
forall (m :: * -> *) a. Monad m => a -> m a
return JannoRow
x
        -- this should be an error, but we have legacy packages with this issue, so it's only a warning
        (Bool
True, Bool
_, Bool
True, Bool
_ )     -> do
            JannoRowWarnings -> ExceptT String (Writer JannoRowWarnings) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
W.tell [String
"Date_Type is \"C14\", but either Date_C14_Uncal_BP or Date_C14_Uncal_BP_Err are empty"]
            JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow
forall a. a -> ExceptT String (Writer JannoRowWarnings) a
forall (m :: * -> *) a. Monad m => a -> m a
return JannoRow
x

checkContamColsConsistent :: JannoRow -> JannoRowLog JannoRow
checkContamColsConsistent :: JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow
checkContamColsConsistent JannoRow
x =
    let lContamination :: Int
lContamination      = Maybe JannoStringList -> Int
forall a. Maybe (JannoList a) -> Int
getCellLength (Maybe JannoStringList -> Int) -> Maybe JannoStringList -> Int
forall a b. (a -> b) -> a -> b
$ JannoRow -> Maybe JannoStringList
jContamination JannoRow
x
        lContaminationErr :: Int
lContaminationErr   = Maybe JannoStringList -> Int
forall a. Maybe (JannoList a) -> Int
getCellLength (Maybe JannoStringList -> Int) -> Maybe JannoStringList -> Int
forall a b. (a -> b) -> a -> b
$ JannoRow -> Maybe JannoStringList
jContaminationErr JannoRow
x
        lContaminationMeas :: Int
lContaminationMeas  = Maybe JannoStringList -> Int
forall a. Maybe (JannoList a) -> Int
getCellLength (Maybe JannoStringList -> Int) -> Maybe JannoStringList -> Int
forall a b. (a -> b) -> a -> b
$ JannoRow -> Maybe JannoStringList
jContaminationMeas JannoRow
x
        allSameLength :: Bool
allSameLength       = [Int] -> Bool
forall a. Eq a => [a] -> Bool
allEqual [Int
lContamination, Int
lContaminationErr, Int
lContaminationMeas]
    in case Bool
allSameLength of
        Bool
False -> String -> ExceptT String (Writer JannoRowWarnings) JannoRow
forall a. String -> ExceptT String (Writer JannoRowWarnings) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
E.throwError String
"Contamination, Contamination_Err and Contamination_Meas \
                      \do not have the same lengths"
        Bool
True  -> JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow
forall a. a -> ExceptT String (Writer JannoRowWarnings) a
forall (m :: * -> *) a. Monad m => a -> m a
return JannoRow
x

checkRelationColsConsistent :: JannoRow -> JannoRowLog JannoRow
checkRelationColsConsistent :: JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow
checkRelationColsConsistent JannoRow
x =
    let lRelationTo :: Int
lRelationTo     = Maybe JannoStringList -> Int
forall a. Maybe (JannoList a) -> Int
getCellLength (Maybe JannoStringList -> Int) -> Maybe JannoStringList -> Int
forall a b. (a -> b) -> a -> b
$ JannoRow -> Maybe JannoStringList
jRelationTo JannoRow
x
        lRelationDegree :: Int
lRelationDegree = Maybe JannoRelationDegreeList -> Int
forall a. Maybe (JannoList a) -> Int
getCellLength (Maybe JannoRelationDegreeList -> Int)
-> Maybe JannoRelationDegreeList -> Int
forall a b. (a -> b) -> a -> b
$ JannoRow -> Maybe JannoRelationDegreeList
jRelationDegree JannoRow
x
        lRelationType :: Int
lRelationType   = Maybe JannoStringList -> Int
forall a. Maybe (JannoList a) -> Int
getCellLength (Maybe JannoStringList -> Int) -> Maybe JannoStringList -> Int
forall a b. (a -> b) -> a -> b
$ JannoRow -> Maybe JannoStringList
jRelationType JannoRow
x
        allSameLength :: Bool
allSameLength   = [Int] -> Bool
forall a. Eq a => [a] -> Bool
allEqual [Int
lRelationTo, Int
lRelationDegree, Int
lRelationType] Bool -> Bool -> Bool
||
                          ([Int] -> Bool
forall a. Eq a => [a] -> Bool
allEqual [Int
lRelationTo, Int
lRelationDegree] Bool -> Bool -> Bool
&& Int
lRelationType Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0)
    in case Bool
allSameLength of
        Bool
False -> String -> ExceptT String (Writer JannoRowWarnings) JannoRow
forall a. String -> ExceptT String (Writer JannoRowWarnings) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
E.throwError String
"Relation_To, Relation_Degree and Relation_Type \
                      \do not have the same lengths. Relation_Type can be empty"
        Bool
True  -> JannoRow -> ExceptT String (Writer JannoRowWarnings) JannoRow
forall a. a -> ExceptT String (Writer JannoRowWarnings) a
forall (m :: * -> *) a. Monad m => a -> m a
return JannoRow
x

-- deriving with TemplateHaskell necessary for the generics magic in the Survey module
deriveGeneric ''JannoRow