{-# LANGUAGE DeriveDataTypeable, DeriveGeneric, PatternSynonyms, OverloadedStrings, Safe #-}

{-|
Module      : Data.Char.Emoji
Description : A module that defines emoji and ways to render and modify emoji.
Maintainer  : hapytexeu+gh@gmail.com
Stability   : experimental
Portability : POSIX

Unicode defines 2182 emoji characters, this module aims to make working with emoji characters more convenient.
-}

module Data.Char.Emoji (
    -- * Emoji suffix
    pattern EmojiSuffix
    -- * Flag emoji
  , Flag, flag, flag', flagChars
  , iso3166Alpha2ToFlag, iso3166Alpha2ToFlag', validFlagEmoji
    -- * Subregional flag emoji
  , SubFlag
    -- * Clock emoji
  , Clock, hours, minutes30, clock, closestClock
    -- * Blood type emoji
  , BloodType(O, B, A, AB)
    -- * Moon phase emoji
  , MoonPhase(NewMoon, WaxingCrescent, FirstQuarter, WaxingGibbous, FullMoon, WaningGibbous, ThirdQuarter, WaningCrescent)
    -- * Gender sign emoji
  , Gender(Female, Male)
    -- * Zodiac emoji
  , Zodiac(Aries, Taurus, Gemini, Cancer, Leo, Virgo, Libra, Scorpio, Sagittarius, Capricorn, Aquarius, Pisces)
    -- * Skin color modifier
  , SkinColorModifier(Light, MediumLight, Medium, MediumDark, Dark), fromFitzPatrick
    -- * Pattern symbols for 'Flag's
  , pattern AC, pattern AD, pattern AE, pattern AF, pattern AG, pattern AI, pattern AL, pattern AM, pattern AO, pattern AQ, pattern AR
  , pattern AS, pattern AT, pattern AU, pattern AW, pattern AX, pattern AZ, pattern BA, pattern BB, pattern BD, pattern BE, pattern BF
  , pattern BG, pattern BH, pattern BI, pattern BJ, pattern BL, pattern BM, pattern BN, pattern BO, pattern BQ, pattern BR, pattern BS
  , pattern BT, pattern BV, pattern BW, pattern BY, pattern BZ, pattern CA, pattern CC, pattern CD, pattern CF, pattern CG, pattern CH
  , pattern CI, pattern CK, pattern CL, pattern CM, pattern CN, pattern CO, pattern CP, pattern CR, pattern CU, pattern CV, pattern CW
  , pattern CX, pattern CY, pattern CZ, pattern DE, pattern DG, pattern DJ, pattern DK, pattern DM, pattern DO, pattern DZ, pattern EA
  , pattern EC, pattern EE, pattern EG, pattern EH, pattern ER, pattern ES, pattern ET, pattern EU, pattern FI, pattern FJ, pattern FK
  , pattern FM, pattern FO, pattern FR, pattern GA, pattern GB, pattern GD, pattern GE, pattern GF, pattern GG, pattern GH, pattern GI
  , pattern GL, pattern GM, pattern GN, pattern GP, pattern GQ, pattern GR, pattern GS, pattern GT, pattern GU, pattern GW, pattern GY
  , pattern HK, pattern HM, pattern HN, pattern HR, pattern HT, pattern HU, pattern IC, pattern ID, pattern IE, pattern IL, pattern IM
  , pattern IN, pattern IO, pattern IQ, pattern IR, pattern IS, pattern IT, pattern JE, pattern JM, pattern JO, pattern JP, pattern KE
  , pattern KG, pattern KH, pattern KI, pattern KM, pattern KN, pattern KP, pattern KR, pattern KW, pattern KY, pattern KZ, pattern LA
  , pattern LB, pattern LC, pattern LI, pattern LK, pattern LR, pattern LS, pattern LT, pattern LU, pattern LV, pattern LY, pattern MA
  , pattern MC, pattern MD, pattern ME, pattern MF, pattern MG, pattern MH, pattern MK, pattern ML, pattern MM, pattern MN, pattern MO
  , pattern MP, pattern MQ, pattern MR, pattern MS, pattern MT, pattern MU, pattern MV, pattern MW, pattern MX, pattern MY, pattern MZ
  , pattern NA, pattern NC, pattern NE, pattern NF, pattern NG, pattern NI, pattern NL, pattern NO, pattern NP, pattern NR, pattern NU
  , pattern NZ, pattern OM, pattern PA, pattern PE, pattern PF, pattern PG, pattern PH, pattern PK, pattern PL, pattern PM, pattern PN
  , pattern PR, pattern PS, pattern PT, pattern PW, pattern PY, pattern QA, pattern RE, pattern RO, pattern RS, pattern RU, pattern RW
  , pattern SA, pattern SB, pattern SC, pattern SD, pattern SE, pattern SG, pattern SH, pattern SI, pattern SJ, pattern SK, pattern SL
  , pattern SM, pattern SN, pattern SO, pattern SR, pattern SS, pattern ST, pattern SV, pattern SX, pattern SY, pattern SZ, pattern TA
  , pattern TC, pattern TD, pattern TF, pattern TG, pattern TH, pattern TJ, pattern TK, pattern TL, pattern TM, pattern TN, pattern TO
  , pattern TR, pattern TT, pattern TV, pattern TW, pattern TZ, pattern UA, pattern UG, pattern UM, pattern UN, pattern US, pattern UY
  , pattern UZ, pattern VA, pattern VC, pattern VE, pattern VG, pattern VI, pattern VN, pattern VU, pattern WF, pattern WS, pattern XK
  , pattern YE, pattern YT, pattern ZA, pattern ZM, pattern ZW
    -- * Pattern synonyms for 'SubFlag's
  , pattern ENG, pattern SCT, pattern WLS
    -- * Pattern synonyms for 'Zodiac' elements
  , pattern Ram, pattern Bull, pattern Twins, pattern Crab, pattern Lion, pattern Maiden, pattern Scales, pattern Scorpius, pattern Scorpion
  , pattern Centaur, pattern Archer, pattern Capricornus, pattern MountainGoat, pattern GoatHorned, pattern SeaGoat, pattern WaterBearer
  , pattern Fish
    -- * Pattern synonyms for the 'SkinColorModifier' elements
  , pattern FitzPatrickI, pattern FitzPatrickII, pattern FitzPatrickIII, pattern FitzPatrickIV, pattern FitzPatrickV, pattern FitzPatrickVI
  ) where

import Prelude hiding (LT, GT)

import Control.DeepSeq(NFData)

import Data.Bits(Bits((.&.), (.|.), bit, bitSize, bitSizeMaybe, complement, isSigned, popCount, rotate, shift, shiftL, shiftR, testBit, xor))
import Data.Bool(bool)
import Data.Char(chr, ord, toUpper, toLower)
import Data.Char.Core(MirrorVertical(mirrorVertical), UnicodeCharacter(toUnicodeChar, fromUnicodeChar, fromUnicodeChar'), UnicodeText(fromUnicodeText, toUnicodeText), mapFromEnum, mapToEnum, mapToEnumSafe)
import Data.Char.Enclosed(regionalIndicatorUppercase')
import Data.Data(Data)
import Data.Function(on)
import Data.Hashable(Hashable)
import Data.Maybe(fromJust)
import Data.Text(Text, pack, unpack)

import GHC.Generics(Generic)
import GHC.Enum(fromEnumError, toEnumError)

import Test.QuickCheck.Arbitrary(Arbitrary(arbitrary), arbitraryBoundedEnum)

-- | A 'Char'acter that is often used as a suffix to turn a character into an
-- emoji.
pattern EmojiSuffix :: Char
pattern $bEmojiSuffix :: Char
$mEmojiSuffix :: forall r. Char -> (Void# -> r) -> (Void# -> r) -> r
EmojiSuffix = '\xfe0f'

_skinColorOffset :: Int
_skinColorOffset :: Int
_skinColorOffset = Int
0x1f3fb

_zodiacOffset :: Int
_zodiacOffset :: Int
_zodiacOffset = Int
0x2648

_moonPhaseOffset :: Int
_moonPhaseOffset :: Int
_moonPhaseOffset = Int
0x1f311

-- | A data type that stores a (country) flag by the two characters of the ISO
-- 3166 Alpa-2 standard. The data constructor is hidden to prevent making flags
-- with a combination of characters that is invalid.
-- Besides the countries defined in the ISO-3166 Alpha-2 standard, only the
-- Antarctica (AQ), the European Union (EU) and the United Nations (UN) have a
-- flag. Deprecated territories like the Soviet Union (SU) and Yugoslavia (YU)
-- have no corresponding flag.
data Flag = Flag Char Char deriving (Typeable Flag
DataType
Constr
Typeable Flag
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Flag -> c Flag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Flag)
-> (Flag -> Constr)
-> (Flag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Flag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Flag))
-> ((forall b. Data b => b -> b) -> Flag -> Flag)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r)
-> (forall u. (forall d. Data d => d -> u) -> Flag -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Flag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Flag -> m Flag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Flag -> m Flag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Flag -> m Flag)
-> Data Flag
Flag -> DataType
Flag -> Constr
(forall b. Data b => b -> b) -> Flag -> Flag
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flag -> c Flag
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Flag
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Flag -> u
forall u. (forall d. Data d => d -> u) -> Flag -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Flag -> m Flag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Flag -> m Flag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Flag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flag -> c Flag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Flag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Flag)
$cFlag :: Constr
$tFlag :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Flag -> m Flag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Flag -> m Flag
gmapMp :: (forall d. Data d => d -> m d) -> Flag -> m Flag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Flag -> m Flag
gmapM :: (forall d. Data d => d -> m d) -> Flag -> m Flag
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Flag -> m Flag
gmapQi :: Int -> (forall d. Data d => d -> u) -> Flag -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Flag -> u
gmapQ :: (forall d. Data d => d -> u) -> Flag -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Flag -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r
gmapT :: (forall b. Data b => b -> b) -> Flag -> Flag
$cgmapT :: (forall b. Data b => b -> b) -> Flag -> Flag
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Flag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Flag)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Flag)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Flag)
dataTypeOf :: Flag -> DataType
$cdataTypeOf :: Flag -> DataType
toConstr :: Flag -> Constr
$ctoConstr :: Flag -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Flag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Flag
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flag -> c Flag
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flag -> c Flag
$cp1Data :: Typeable Flag
Data, Flag -> Flag -> Bool
(Flag -> Flag -> Bool) -> (Flag -> Flag -> Bool) -> Eq Flag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Flag -> Flag -> Bool
$c/= :: Flag -> Flag -> Bool
== :: Flag -> Flag -> Bool
$c== :: Flag -> Flag -> Bool
Eq, (forall x. Flag -> Rep Flag x)
-> (forall x. Rep Flag x -> Flag) -> Generic Flag
forall x. Rep Flag x -> Flag
forall x. Flag -> Rep Flag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Flag x -> Flag
$cfrom :: forall x. Flag -> Rep Flag x
Generic, Eq Flag
Eq Flag
-> (Flag -> Flag -> Ordering)
-> (Flag -> Flag -> Bool)
-> (Flag -> Flag -> Bool)
-> (Flag -> Flag -> Bool)
-> (Flag -> Flag -> Bool)
-> (Flag -> Flag -> Flag)
-> (Flag -> Flag -> Flag)
-> Ord Flag
Flag -> Flag -> Bool
Flag -> Flag -> Ordering
Flag -> Flag -> Flag
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Flag -> Flag -> Flag
$cmin :: Flag -> Flag -> Flag
max :: Flag -> Flag -> Flag
$cmax :: Flag -> Flag -> Flag
>= :: Flag -> Flag -> Bool
$c>= :: Flag -> Flag -> Bool
> :: Flag -> Flag -> Bool
$c> :: Flag -> Flag -> Bool
<= :: Flag -> Flag -> Bool
$c<= :: Flag -> Flag -> Bool
< :: Flag -> Flag -> Bool
$c< :: Flag -> Flag -> Bool
compare :: Flag -> Flag -> Ordering
$ccompare :: Flag -> Flag -> Ordering
$cp1Ord :: Eq Flag
Ord, ReadPrec [Flag]
ReadPrec Flag
Int -> ReadS Flag
ReadS [Flag]
(Int -> ReadS Flag)
-> ReadS [Flag] -> ReadPrec Flag -> ReadPrec [Flag] -> Read Flag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Flag]
$creadListPrec :: ReadPrec [Flag]
readPrec :: ReadPrec Flag
$creadPrec :: ReadPrec Flag
readList :: ReadS [Flag]
$creadList :: ReadS [Flag]
readsPrec :: Int -> ReadS Flag
$creadsPrec :: Int -> ReadS Flag
Read, Int -> Flag -> ShowS
[Flag] -> ShowS
Flag -> String
(Int -> Flag -> ShowS)
-> (Flag -> String) -> ([Flag] -> ShowS) -> Show Flag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Flag] -> ShowS
$cshowList :: [Flag] -> ShowS
show :: Flag -> String
$cshow :: Flag -> String
showsPrec :: Int -> Flag -> ShowS
$cshowsPrec :: Int -> Flag -> ShowS
Show)

instance Hashable Flag

instance NFData Flag

-- | A data type to store a subregion flag. This is specified by the /parent/
-- flag, and three characters of the subregion. At the moment, the only three
-- subregional flags are /England/ (eng), /Scotland/ (sct) and /Wales/ (wls),
-- all beloning under the /United Kingdom/ flag (GB).
-- The data constructor is made private to prevent making non-existing subflags.
data SubFlag = SubFlag Flag Char Char Char deriving (Typeable SubFlag
DataType
Constr
Typeable SubFlag
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SubFlag -> c SubFlag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SubFlag)
-> (SubFlag -> Constr)
-> (SubFlag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SubFlag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubFlag))
-> ((forall b. Data b => b -> b) -> SubFlag -> SubFlag)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SubFlag -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SubFlag -> r)
-> (forall u. (forall d. Data d => d -> u) -> SubFlag -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SubFlag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SubFlag -> m SubFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SubFlag -> m SubFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SubFlag -> m SubFlag)
-> Data SubFlag
SubFlag -> DataType
SubFlag -> Constr
(forall b. Data b => b -> b) -> SubFlag -> SubFlag
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubFlag -> c SubFlag
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubFlag
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SubFlag -> u
forall u. (forall d. Data d => d -> u) -> SubFlag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubFlag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SubFlag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubFlag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubFlag -> c SubFlag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SubFlag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubFlag)
$cSubFlag :: Constr
$tSubFlag :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
gmapMp :: (forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
gmapM :: (forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
gmapQi :: Int -> (forall d. Data d => d -> u) -> SubFlag -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SubFlag -> u
gmapQ :: (forall d. Data d => d -> u) -> SubFlag -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SubFlag -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SubFlag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SubFlag -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubFlag -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubFlag -> r
gmapT :: (forall b. Data b => b -> b) -> SubFlag -> SubFlag
$cgmapT :: (forall b. Data b => b -> b) -> SubFlag -> SubFlag
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubFlag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubFlag)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SubFlag)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SubFlag)
dataTypeOf :: SubFlag -> DataType
$cdataTypeOf :: SubFlag -> DataType
toConstr :: SubFlag -> Constr
$ctoConstr :: SubFlag -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubFlag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubFlag
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubFlag -> c SubFlag
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubFlag -> c SubFlag
$cp1Data :: Typeable SubFlag
Data, SubFlag -> SubFlag -> Bool
(SubFlag -> SubFlag -> Bool)
-> (SubFlag -> SubFlag -> Bool) -> Eq SubFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubFlag -> SubFlag -> Bool
$c/= :: SubFlag -> SubFlag -> Bool
== :: SubFlag -> SubFlag -> Bool
$c== :: SubFlag -> SubFlag -> Bool
Eq, (forall x. SubFlag -> Rep SubFlag x)
-> (forall x. Rep SubFlag x -> SubFlag) -> Generic SubFlag
forall x. Rep SubFlag x -> SubFlag
forall x. SubFlag -> Rep SubFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SubFlag x -> SubFlag
$cfrom :: forall x. SubFlag -> Rep SubFlag x
Generic, Eq SubFlag
Eq SubFlag
-> (SubFlag -> SubFlag -> Ordering)
-> (SubFlag -> SubFlag -> Bool)
-> (SubFlag -> SubFlag -> Bool)
-> (SubFlag -> SubFlag -> Bool)
-> (SubFlag -> SubFlag -> Bool)
-> (SubFlag -> SubFlag -> SubFlag)
-> (SubFlag -> SubFlag -> SubFlag)
-> Ord SubFlag
SubFlag -> SubFlag -> Bool
SubFlag -> SubFlag -> Ordering
SubFlag -> SubFlag -> SubFlag
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SubFlag -> SubFlag -> SubFlag
$cmin :: SubFlag -> SubFlag -> SubFlag
max :: SubFlag -> SubFlag -> SubFlag
$cmax :: SubFlag -> SubFlag -> SubFlag
>= :: SubFlag -> SubFlag -> Bool
$c>= :: SubFlag -> SubFlag -> Bool
> :: SubFlag -> SubFlag -> Bool
$c> :: SubFlag -> SubFlag -> Bool
<= :: SubFlag -> SubFlag -> Bool
$c<= :: SubFlag -> SubFlag -> Bool
< :: SubFlag -> SubFlag -> Bool
$c< :: SubFlag -> SubFlag -> Bool
compare :: SubFlag -> SubFlag -> Ordering
$ccompare :: SubFlag -> SubFlag -> Ordering
$cp1Ord :: Eq SubFlag
Ord, ReadPrec [SubFlag]
ReadPrec SubFlag
Int -> ReadS SubFlag
ReadS [SubFlag]
(Int -> ReadS SubFlag)
-> ReadS [SubFlag]
-> ReadPrec SubFlag
-> ReadPrec [SubFlag]
-> Read SubFlag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SubFlag]
$creadListPrec :: ReadPrec [SubFlag]
readPrec :: ReadPrec SubFlag
$creadPrec :: ReadPrec SubFlag
readList :: ReadS [SubFlag]
$creadList :: ReadS [SubFlag]
readsPrec :: Int -> ReadS SubFlag
$creadsPrec :: Int -> ReadS SubFlag
Read, Int -> SubFlag -> ShowS
[SubFlag] -> ShowS
SubFlag -> String
(Int -> SubFlag -> ShowS)
-> (SubFlag -> String) -> ([SubFlag] -> ShowS) -> Show SubFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SubFlag] -> ShowS
$cshowList :: [SubFlag] -> ShowS
show :: SubFlag -> String
$cshow :: SubFlag -> String
showsPrec :: Int -> SubFlag -> ShowS
$cshowsPrec :: Int -> SubFlag -> ShowS
Show)

instance Bounded Flag where
    minBound :: Flag
minBound = Flag
AC
    maxBound :: Flag
maxBound = Flag
ZW

instance Hashable SubFlag

instance NFData SubFlag

-- | Convert the given two characters that represent a flag according to the ISO
-- 3166 Alpha-2 standard to a 'Flag' wrapped in a 'Just' data constructor, if
-- that flag exists; 'Nothing' otherwise.
-- One can pass characters in upper case (@A-Z@) and lower case (@a-z@). The
-- flag will hold the upper case variant.
-- The Emoji have flags for the countries defined by the ISO 3166 Alpha-2
-- standard without deprecated regions like the Soviet Union (SU) and Yugoslavia
-- (YU). Furthermore there are Emoji for the flags of Antarctica (AQ), the
-- European Union (EU) and the United Nations (UN).
flag
  :: Char  -- ^ The first character of the ISO 3166 Alpha-2 standard.
  -> Char  -- ^ The second character of the ISO 3166 Alpha-2 standard.
  -> Maybe Flag  -- ^ A 'Flag' object wrapped in a 'Just' data constructor, given such flag exists; 'Nothing' otherwise.
flag :: Char -> Char -> Maybe Flag
flag Char
ca Char
cb
    | Char -> Char -> Bool
_validFlagEmoji Char
a Char
b = Flag -> Maybe Flag
forall a. a -> Maybe a
Just (Char -> Char -> Flag
Flag Char
a Char
b)
    | Bool
otherwise = Maybe Flag
forall a. Maybe a
Nothing
    where a :: Char
a = Char -> Char
toUpper Char
ca
          b :: Char
b = Char -> Char
toUpper Char
cb

-- | Convert the given two characters that represent a flag according to the ISO
-- 3166 Alpha-2 standard to a 'Flag'. If the flag does not exists, then the
-- result is unspecified.
-- One can pass characters in upper case (@A-Z@) and lower case (@a-z@). The
-- flag will hold the upper case variant.
-- The Emoji have flags for the countries defined by the ISO 3166 Alpha-2
-- standard without deprecated regions like the Soviet Union (SU) and Yugoslavia
-- (YU). Furthermore there are Emoji for the flags of Antarctica (AQ), the
-- European Union (EU) and the United Nations (UN).
flag'
  :: Char  -- ^ The first character of the ISO 3166 Alpha-2 standard.
  -> Char  -- ^ The second character of the ISO 3166 Alpha-2 standard.
  -> Flag  -- ^ The equivalent 'Flag' object.
flag' :: Char -> Char -> Flag
flag' Char
ca = Maybe Flag -> Flag
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Flag -> Flag) -> (Char -> Maybe Flag) -> Char -> Flag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char -> Maybe Flag
flag Char
ca

-- | Obtain the two-characters that specify the given 'Flag'. These two
-- characters are always upper case (@A-Z@).
flagChars
  :: Flag  -- ^ The given 'Flag' to convert to a 2-tuple of 'Char'acters.
  -> (Char, Char)  -- ^ A 2-tuple that contains upper case 'Char'acters for the given 'Flag'.
flagChars :: Flag -> (Char, Char)
flagChars (Flag Char
ca Char
cb) = (Char
ca, Char
cb)

-- | The 'Flag' pattern used for /Ascension Island/ denoted with /AC/.
pattern AC :: Flag
pattern $bAC :: Flag
$mAC :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
AC = Flag 'A' 'C'

-- | The 'Flag' pattern used for /Andorra/ denoted with /AD/.
pattern AD :: Flag
pattern $bAD :: Flag
$mAD :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
AD = Flag 'A' 'D'

-- | The 'Flag' pattern used for the /United Arab Emirates/ denoted with /AE/.
pattern AE :: Flag
pattern $bAE :: Flag
$mAE :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
AE = Flag 'A' 'E'

-- | The 'Flag' pattern used for /Afghanistan/ denoted with /AF/.
pattern AF :: Flag
pattern $bAF :: Flag
$mAF :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
AF = Flag 'A' 'F'

-- | The 'Flag' pattern used for /Antigua & Barbuda/ denoted with /AG/.
pattern AG :: Flag
pattern $bAG :: Flag
$mAG :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
AG = Flag 'A' 'G'

-- | The 'Flag' pattern used for /Anguilla/ denoted with /AI/.
pattern AI :: Flag
pattern $bAI :: Flag
$mAI :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
AI = Flag 'A' 'I'

-- | The 'Flag' pattern used for /Albania/ denoted with /AL/.
pattern AL :: Flag
pattern $bAL :: Flag
$mAL :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
AL = Flag 'A' 'L'

-- | The 'Flag' pattern used for /Armenia/ denoted with /AM/.
pattern AM :: Flag
pattern $bAM :: Flag
$mAM :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
AM = Flag 'A' 'M'

-- | The 'Flag' pattern used for /Angola/ denoted with /AO/.
pattern AO :: Flag
pattern $bAO :: Flag
$mAO :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
AO = Flag 'A' 'O'

-- | The 'Flag' pattern used for /Antarctica/ denoted with /AQ/.
pattern AQ :: Flag
pattern $bAQ :: Flag
$mAQ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
AQ = Flag 'A' 'Q'

-- | The 'Flag' pattern used for /Argentina/ denoted with /AR/.
pattern AR :: Flag
pattern $bAR :: Flag
$mAR :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
AR = Flag 'A' 'R'

-- | The 'Flag' pattern used for /American Samoa/ denoted with /AS/.
pattern AS :: Flag
pattern $bAS :: Flag
$mAS :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
AS = Flag 'A' 'S'

-- | The 'Flag' pattern used for /Austria/ denoted with /AT/.
pattern AT :: Flag
pattern $bAT :: Flag
$mAT :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
AT = Flag 'A' 'T'

-- | The 'Flag' pattern used for /Australia/ denoted with /AU/.
pattern AU :: Flag
pattern $bAU :: Flag
$mAU :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
AU = Flag 'A' 'U'

-- | The 'Flag' pattern used for /Aruba/ denoted with /AW/.
pattern AW :: Flag
pattern $bAW :: Flag
$mAW :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
AW = Flag 'A' 'W'

-- | The 'Flag' pattern used for the /Åland Islands/ denoted with /AX/.
pattern AX :: Flag
pattern $bAX :: Flag
$mAX :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
AX = Flag 'A' 'X'

-- | The 'Flag' pattern used for /Azerbaijan/ denoted with /AZ/.
pattern AZ :: Flag
pattern $bAZ :: Flag
$mAZ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
AZ = Flag 'A' 'Z'

-- | The 'Flag' pattern used for /Bosnia & Herzegovina/ denoted with /BA/.
pattern BA :: Flag
pattern $bBA :: Flag
$mBA :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BA = Flag 'B' 'A'

-- | The 'Flag' pattern used for /Barbados/ denoted with /BB/.
pattern BB :: Flag
pattern $bBB :: Flag
$mBB :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BB = Flag 'B' 'B'

-- | The 'Flag' pattern used for /Bangladesh/ denoted with /BD/.
pattern BD :: Flag
pattern $bBD :: Flag
$mBD :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BD = Flag 'B' 'D'

-- | The 'Flag' pattern used for /Belgium/ denoted with /BE/.
pattern BE :: Flag
pattern $bBE :: Flag
$mBE :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BE = Flag 'B' 'E'

-- | The 'Flag' pattern used for /Burkina Faso/ denoted with /BF/.
pattern BF :: Flag
pattern $bBF :: Flag
$mBF :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BF = Flag 'B' 'F'

-- | The 'Flag' pattern used for /Bulgaria/ denoted with /BG/.
pattern BG :: Flag
pattern $bBG :: Flag
$mBG :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BG = Flag 'B' 'G'

-- | The 'Flag' pattern used for /Bahrain/ denoted with /BH/.
pattern BH :: Flag
pattern $bBH :: Flag
$mBH :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BH = Flag 'B' 'H'

-- | The 'Flag' pattern used for /Burundi/ denoted with /BI/.
pattern BI :: Flag
pattern $bBI :: Flag
$mBI :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BI = Flag 'B' 'I'

-- | The 'Flag' pattern used for /Benin/ denoted with /BJ/.
pattern BJ :: Flag
pattern $bBJ :: Flag
$mBJ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BJ = Flag 'B' 'J'

-- | The 'Flag' pattern used for /St. Barthélemy/ denoted with /BL/.
pattern BL :: Flag
pattern $bBL :: Flag
$mBL :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BL = Flag 'B' 'L'

-- | The 'Flag' pattern used for /Bermuda/ denoted with /BM/.
pattern BM :: Flag
pattern $bBM :: Flag
$mBM :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BM = Flag 'B' 'M'

-- | The 'Flag' pattern used for /Brunei/ denoted with /BN/.
pattern BN :: Flag
pattern $bBN :: Flag
$mBN :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BN = Flag 'B' 'N'

-- | The 'Flag' pattern used for /Bolivia/ denoted with /BO/.
pattern BO :: Flag
pattern $bBO :: Flag
$mBO :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BO = Flag 'B' 'O'

-- | The 'Flag' pattern used for the /Caribbean Netherlands/ denoted with /BQ/.
pattern BQ :: Flag
pattern $bBQ :: Flag
$mBQ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BQ = Flag 'B' 'Q'

-- | The 'Flag' pattern used for /Brazil/ denoted with /BR/.
pattern BR :: Flag
pattern $bBR :: Flag
$mBR :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BR = Flag 'B' 'R'

-- | The 'Flag' pattern used for the /Bahamas/ denoted with /BS/.
pattern BS :: Flag
pattern $bBS :: Flag
$mBS :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BS = Flag 'B' 'S'

-- | The 'Flag' pattern used for /Bhutan/ denoted with /BT/.
pattern BT :: Flag
pattern $bBT :: Flag
$mBT :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BT = Flag 'B' 'T'

-- | The 'Flag' pattern used for /Bouvet Island/ denoted with /BV/.
pattern BV :: Flag
pattern $bBV :: Flag
$mBV :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BV = Flag 'B' 'V'

-- | The 'Flag' pattern used for /Botswana/ denoted with /BW/.
pattern BW :: Flag
pattern $bBW :: Flag
$mBW :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BW = Flag 'B' 'W'

-- | The 'Flag' pattern used for /Belarus/ denoted with /BY/.
pattern BY :: Flag
pattern $bBY :: Flag
$mBY :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BY = Flag 'B' 'Y'

-- | The 'Flag' pattern used for /Belize/ denoted with /BZ/.
pattern BZ :: Flag
pattern $bBZ :: Flag
$mBZ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
BZ = Flag 'B' 'Z'

-- | The 'Flag' pattern used for /Canada/ denoted with /CA/.
pattern CA :: Flag
pattern $bCA :: Flag
$mCA :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CA = Flag 'C' 'A'

-- | The 'Flag' pattern used for the /Cocos (Keeling) Islands/ denoted with /CC/.
pattern CC :: Flag
pattern $bCC :: Flag
$mCC :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CC = Flag 'C' 'C'

-- | The 'Flag' pattern used for /Congo - Kinshasa/ denoted with /CD/.
pattern CD :: Flag
pattern $bCD :: Flag
$mCD :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CD = Flag 'C' 'D'

-- | The 'Flag' pattern used for /Central African Republic/ denoted with /CF/.
pattern CF :: Flag
pattern $bCF :: Flag
$mCF :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CF = Flag 'C' 'F'

-- | The 'Flag' pattern used for /Congo - Brazzaville/ denoted with /CG/.
pattern CG :: Flag
pattern $bCG :: Flag
$mCG :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CG = Flag 'C' 'G'

-- | The 'Flag' pattern used for /Switzerland/ denoted with /CH/.
pattern CH :: Flag
pattern $bCH :: Flag
$mCH :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CH = Flag 'C' 'H'

-- | The 'Flag' pattern used for /Côte d’Ivoire/ denoted with /CI/.
pattern CI :: Flag
pattern $bCI :: Flag
$mCI :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CI = Flag 'C' 'I'

-- | The 'Flag' pattern used for the /Cook Islands/ denoted with /CK/.
pattern CK :: Flag
pattern $bCK :: Flag
$mCK :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CK = Flag 'C' 'K'

-- | The 'Flag' pattern used for /Chile/ denoted with /CL/.
pattern CL :: Flag
pattern $bCL :: Flag
$mCL :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CL = Flag 'C' 'L'

-- | The 'Flag' pattern used for /Cameroon/ denoted with /CM/.
pattern CM :: Flag
pattern $bCM :: Flag
$mCM :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CM = Flag 'C' 'M'

-- | The 'Flag' pattern used for /China/ denoted with /CN/.
pattern CN :: Flag
pattern $bCN :: Flag
$mCN :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CN = Flag 'C' 'N'

-- | The 'Flag' pattern used for /Colombia/ denoted with /CO/.
pattern CO :: Flag
pattern $bCO :: Flag
$mCO :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CO = Flag 'C' 'O'

-- | The 'Flag' pattern used for /Clipperton Island/ denoted with /CP/.
pattern CP :: Flag
pattern $bCP :: Flag
$mCP :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CP = Flag 'C' 'P'

-- | The 'Flag' pattern used for /Costa Rica/ denoted with /CR/.
pattern CR :: Flag
pattern $bCR :: Flag
$mCR :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CR = Flag 'C' 'R'

-- | The 'Flag' pattern used for /Cuba/ denoted with /CU/.
pattern CU :: Flag
pattern $bCU :: Flag
$mCU :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CU = Flag 'C' 'U'

-- | The 'Flag' pattern used for /Cape Verde/ denoted with /CV/.
pattern CV :: Flag
pattern $bCV :: Flag
$mCV :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CV = Flag 'C' 'V'

-- | The 'Flag' pattern used for /Curaçao/ denoted with /CW/.
pattern CW :: Flag
pattern $bCW :: Flag
$mCW :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CW = Flag 'C' 'W'

-- | The 'Flag' pattern used for /Christmas Island/ denoted with /CX/.
pattern CX :: Flag
pattern $bCX :: Flag
$mCX :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CX = Flag 'C' 'X'

-- | The 'Flag' pattern used for /Cyprus/ denoted with /CY/.
pattern CY :: Flag
pattern $bCY :: Flag
$mCY :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CY = Flag 'C' 'Y'

-- | The 'Flag' pattern used for /Czechia/ denoted with /CZ/.
pattern CZ :: Flag
pattern $bCZ :: Flag
$mCZ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
CZ = Flag 'C' 'Z'

-- | The 'Flag' pattern used for /Germany/ denoted with /DE/.
pattern DE :: Flag
pattern $bDE :: Flag
$mDE :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
DE = Flag 'D' 'E'

-- | The 'Flag' pattern used for /Diego Garcia/ denoted with /DG/.
pattern DG :: Flag
pattern $bDG :: Flag
$mDG :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
DG = Flag 'D' 'G'

-- | The 'Flag' pattern used for /Djibouti/ denoted with /DJ/.
pattern DJ :: Flag
pattern $bDJ :: Flag
$mDJ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
DJ = Flag 'D' 'J'

-- | The 'Flag' pattern used for /Denmark/ denoted with /DK/.
pattern DK :: Flag
pattern $bDK :: Flag
$mDK :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
DK = Flag 'D' 'K'

-- | The 'Flag' pattern used for /Dominica/ denoted with /DM/.
pattern DM :: Flag
pattern $bDM :: Flag
$mDM :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
DM = Flag 'D' 'M'

-- | The 'Flag' pattern used for /Dominican Republic/ denoted with /DO/.
pattern DO :: Flag
pattern $bDO :: Flag
$mDO :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
DO = Flag 'D' 'O'

-- | The 'Flag' pattern used for /Algeria/ denoted with /DZ/.
pattern DZ :: Flag
pattern $bDZ :: Flag
$mDZ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
DZ = Flag 'D' 'Z'

-- | The 'Flag' pattern used for /Ceuta & Melilla/ denoted with /EA/.
pattern EA :: Flag
pattern $bEA :: Flag
$mEA :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
EA = Flag 'E' 'A'

-- | The 'Flag' pattern used for /Ecuador/ denoted with /EC/.
pattern EC :: Flag
pattern $bEC :: Flag
$mEC :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
EC = Flag 'E' 'C'

-- | The 'Flag' pattern used for /Estonia/ denoted with /EE/.
pattern EE :: Flag
pattern $bEE :: Flag
$mEE :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
EE = Flag 'E' 'E'

-- | The 'Flag' pattern used for /Egypt/ denoted with /EG/.
pattern EG :: Flag
pattern $bEG :: Flag
$mEG :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
EG = Flag 'E' 'G'

-- | The 'Flag' pattern used for /Western Sahara/ denoted with /EH/.
pattern EH :: Flag
pattern $bEH :: Flag
$mEH :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
EH = Flag 'E' 'H'

-- | The 'Flag' pattern used for /Eritrea/ denoted with /ER/.
pattern ER :: Flag
pattern $bER :: Flag
$mER :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
ER = Flag 'E' 'R'

-- | The 'Flag' pattern used for /Spain/ denoted with /ES/.
pattern ES :: Flag
pattern $bES :: Flag
$mES :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
ES = Flag 'E' 'S'

-- | The 'Flag' pattern used for /Ethiopia/ denoted with /ET/.
pattern ET :: Flag
pattern $bET :: Flag
$mET :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
ET = Flag 'E' 'T'

-- | The 'Flag' pattern used for the /European Union/ denoted with /EU/.
pattern EU :: Flag
pattern $bEU :: Flag
$mEU :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
EU = Flag 'E' 'U'

-- | The 'Flag' pattern used for /Finland/ denoted with /FI/.
pattern FI :: Flag
pattern $bFI :: Flag
$mFI :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
FI = Flag 'F' 'I'

-- | The 'Flag' pattern used for /Fiji/ denoted with /FJ/.
pattern FJ :: Flag
pattern $bFJ :: Flag
$mFJ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
FJ = Flag 'F' 'J'

-- | The 'Flag' pattern used for the /Falkland Islands/ denoted with /FK/.
pattern FK :: Flag
pattern $bFK :: Flag
$mFK :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
FK = Flag 'F' 'K'

-- | The 'Flag' pattern used for /Micronesia/ denoted with /FM/.
pattern FM :: Flag
pattern $bFM :: Flag
$mFM :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
FM = Flag 'F' 'M'

-- | The 'Flag' pattern used for the /Faroe Islands/ denoted with /FO/.
pattern FO :: Flag
pattern $bFO :: Flag
$mFO :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
FO = Flag 'F' 'O'

-- | The 'Flag' pattern used for /France/ denoted with /FR/.
pattern FR :: Flag
pattern $bFR :: Flag
$mFR :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
FR = Flag 'F' 'R'

-- | The 'Flag' pattern used for /Gabon/ denoted with /GA/.
pattern GA :: Flag
pattern $bGA :: Flag
$mGA :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GA = Flag 'G' 'A'

-- | The 'Flag' pattern used for /United Kingdom/ denoted with /GB/.
pattern GB :: Flag
pattern $bGB :: Flag
$mGB :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GB = Flag 'G' 'B'

-- | The 'Flag' pattern used for /Grenada/ denoted with /GD/.
pattern GD :: Flag
pattern $bGD :: Flag
$mGD :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GD = Flag 'G' 'D'

-- | The 'Flag' pattern used for /Georgia/ denoted with /GE/.
pattern GE :: Flag
pattern $bGE :: Flag
$mGE :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GE = Flag 'G' 'E'

-- | The 'Flag' pattern used for /French Guiana/ denoted with /GF/.
pattern GF :: Flag
pattern $bGF :: Flag
$mGF :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GF = Flag 'G' 'F'

-- | The 'Flag' pattern used for /Guernsey/ denoted with /GG/.
pattern GG :: Flag
pattern $bGG :: Flag
$mGG :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GG = Flag 'G' 'G'

-- | The 'Flag' pattern used for /Ghana/ denoted with /GH/.
pattern GH :: Flag
pattern $bGH :: Flag
$mGH :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GH = Flag 'G' 'H'

-- | The 'Flag' pattern used for /Gibraltar/ denoted with /GI/.
pattern GI :: Flag
pattern $bGI :: Flag
$mGI :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GI = Flag 'G' 'I'

-- | The 'Flag' pattern used for /Greenland/ denoted with /GL/.
pattern GL :: Flag
pattern $bGL :: Flag
$mGL :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GL = Flag 'G' 'L'

-- | The 'Flag' pattern used for /Gambia/ denoted with /GM/.
pattern GM :: Flag
pattern $bGM :: Flag
$mGM :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GM = Flag 'G' 'M'

-- | The 'Flag' pattern used for /Guinea/ denoted with /GN/.
pattern GN :: Flag
pattern $bGN :: Flag
$mGN :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GN = Flag 'G' 'N'

-- | The 'Flag' pattern used for /Guadeloupe/ denoted with /GP/.
pattern GP :: Flag
pattern $bGP :: Flag
$mGP :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GP = Flag 'G' 'P'

-- | The 'Flag' pattern used for /Equatorial Guinea/ denoted with /GQ/.
pattern GQ :: Flag
pattern $bGQ :: Flag
$mGQ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GQ = Flag 'G' 'Q'

-- | The 'Flag' pattern used for /Greece/ denoted with /GR/.
pattern GR :: Flag
pattern $bGR :: Flag
$mGR :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GR = Flag 'G' 'R'

-- | The 'Flag' pattern used for the /South Georgia & South Sandwich Islands/ denoted with /GS/.
pattern GS :: Flag
pattern $bGS :: Flag
$mGS :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GS = Flag 'G' 'S'

-- | The 'Flag' pattern used for /Guatemala/ denoted with /GT/.
pattern GT :: Flag
pattern $bGT :: Flag
$mGT :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GT = Flag 'G' 'T'

-- | The 'Flag' pattern used for /Guam/ denoted with /GU/.
pattern GU :: Flag
pattern $bGU :: Flag
$mGU :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GU = Flag 'G' 'U'

-- | The 'Flag' pattern used for /Guinea-Bissau/ denoted with /GW/.
pattern GW :: Flag
pattern $bGW :: Flag
$mGW :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GW = Flag 'G' 'W'

-- | The 'Flag' pattern used for /Guyana/ denoted with /GY/.
pattern GY :: Flag
pattern $bGY :: Flag
$mGY :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
GY = Flag 'G' 'Y'

-- | The 'Flag' pattern used for /Hong Kong SAR China/ denoted with /HK/.
pattern HK :: Flag
pattern $bHK :: Flag
$mHK :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
HK = Flag 'H' 'K'

-- | The 'Flag' pattern used for the /Heard & McDonald Islands/ denoted with /HM/.
pattern HM :: Flag
pattern $bHM :: Flag
$mHM :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
HM = Flag 'H' 'M'

-- | The 'Flag' pattern used for /Honduras/ denoted with /HN/.
pattern HN :: Flag
pattern $bHN :: Flag
$mHN :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
HN = Flag 'H' 'N'

-- | The 'Flag' pattern used for /Croatia/ denoted with /HR/.
pattern HR :: Flag
pattern $bHR :: Flag
$mHR :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
HR = Flag 'H' 'R'

-- | The 'Flag' pattern used for /Haiti/ denoted with /HT/.
pattern HT :: Flag
pattern $bHT :: Flag
$mHT :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
HT = Flag 'H' 'T'

-- | The 'Flag' pattern used for /Hungary/ denoted with /HU/.
pattern HU :: Flag
pattern $bHU :: Flag
$mHU :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
HU = Flag 'H' 'U'

-- | The 'Flag' pattern used for the /Canary Islands/ denoted with /IC/.
pattern IC :: Flag
pattern $bIC :: Flag
$mIC :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
IC = Flag 'I' 'C'

-- | The 'Flag' pattern used for /Indonesia/ denoted with /ID/.
pattern ID :: Flag
pattern $bID :: Flag
$mID :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
ID = Flag 'I' 'D'

-- | The 'Flag' pattern used for /Ireland/ denoted with /IE/.
pattern IE :: Flag
pattern $bIE :: Flag
$mIE :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
IE = Flag 'I' 'E'

-- | The 'Flag' pattern used for /Israel/ denoted with /IL/.
pattern IL :: Flag
pattern $bIL :: Flag
$mIL :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
IL = Flag 'I' 'L'

-- | The 'Flag' pattern used for /Isle of Man/ denoted with /IM/.
pattern IM :: Flag
pattern $bIM :: Flag
$mIM :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
IM = Flag 'I' 'M'

-- | The 'Flag' pattern used for /India/ denoted with /IN/.
pattern IN :: Flag
pattern $bIN :: Flag
$mIN :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
IN = Flag 'I' 'N'

-- | The 'Flag' pattern used for /British Indian Ocean Territory/ denoted with /IO/.
pattern IO :: Flag
pattern $bIO :: Flag
$mIO :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
IO = Flag 'I' 'O'

-- | The 'Flag' pattern used for /Iraq/ denoted with /IQ/.
pattern IQ :: Flag
pattern $bIQ :: Flag
$mIQ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
IQ = Flag 'I' 'Q'

-- | The 'Flag' pattern used for /Iran/ denoted with /IR/.
pattern IR :: Flag
pattern $bIR :: Flag
$mIR :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
IR = Flag 'I' 'R'

-- | The 'Flag' pattern used for /Iceland/ denoted with /IS/.
pattern IS :: Flag
pattern $bIS :: Flag
$mIS :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
IS = Flag 'I' 'S'

-- | The 'Flag' pattern used for /Italy/ denoted with /IT/.
pattern IT :: Flag
pattern $bIT :: Flag
$mIT :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
IT = Flag 'I' 'T'

-- | The 'Flag' pattern used for /Jersey/ denoted with /JE/.
pattern JE :: Flag
pattern $bJE :: Flag
$mJE :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
JE = Flag 'J' 'E'

-- | The 'Flag' pattern used for /Jamaica/ denoted with /JM/.
pattern JM :: Flag
pattern $bJM :: Flag
$mJM :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
JM = Flag 'J' 'M'

-- | The 'Flag' pattern used for /Jordan/ denoted with /JO/.
pattern JO :: Flag
pattern $bJO :: Flag
$mJO :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
JO = Flag 'J' 'O'

-- | The 'Flag' pattern used for /Japan/ denoted with /JP/.
pattern JP :: Flag
pattern $bJP :: Flag
$mJP :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
JP = Flag 'J' 'P'

-- | The 'Flag' pattern used for /Kenya/ denoted with /KE/.
pattern KE :: Flag
pattern $bKE :: Flag
$mKE :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
KE = Flag 'K' 'E'

-- | The 'Flag' pattern used for /Kyrgyzstan/ denoted with /KG/.
pattern KG :: Flag
pattern $bKG :: Flag
$mKG :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
KG = Flag 'K' 'G'

-- | The 'Flag' pattern used for /Cambodia/ denoted with /KH/.
pattern KH :: Flag
pattern $bKH :: Flag
$mKH :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
KH = Flag 'K' 'H'

-- | The 'Flag' pattern used for /Kiribati/ denoted with /KI/.
pattern KI :: Flag
pattern $bKI :: Flag
$mKI :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
KI = Flag 'K' 'I'

-- | The 'Flag' pattern used for the /Comoros/ denoted with /KM/.
pattern KM :: Flag
pattern $bKM :: Flag
$mKM :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
KM = Flag 'K' 'M'

-- | The 'Flag' pattern used for /St. Kitts & Nevis/ denoted with /KN/.
pattern KN :: Flag
pattern $bKN :: Flag
$mKN :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
KN = Flag 'K' 'N'

-- | The 'Flag' pattern used for /North Korea/ denoted with /KP/.
pattern KP :: Flag
pattern $bKP :: Flag
$mKP :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
KP = Flag 'K' 'P'

-- | The 'Flag' pattern used for /South Korea/ denoted with /KR/.
pattern KR :: Flag
pattern $bKR :: Flag
$mKR :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
KR = Flag 'K' 'R'

-- | The 'Flag' pattern used for /Kuwait/ denoted with /KW/.
pattern KW :: Flag
pattern $bKW :: Flag
$mKW :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
KW = Flag 'K' 'W'

-- | The 'Flag' pattern used for the /Cayman Islands/ denoted with /KY/.
pattern KY :: Flag
pattern $bKY :: Flag
$mKY :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
KY = Flag 'K' 'Y'

-- | The 'Flag' pattern used for /Kazakhstan/ denoted with /KZ/.
pattern KZ :: Flag
pattern $bKZ :: Flag
$mKZ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
KZ = Flag 'K' 'Z'

-- | The 'Flag' pattern used for /Laos/ denoted with /LA/.
pattern LA :: Flag
pattern $bLA :: Flag
$mLA :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
LA = Flag 'L' 'A'

-- | The 'Flag' pattern used for /Lebanon/ denoted with /LB/.
pattern LB :: Flag
pattern $bLB :: Flag
$mLB :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
LB = Flag 'L' 'B'

-- | The 'Flag' pattern used for /St. Lucia/ denoted with /LC/.
pattern LC :: Flag
pattern $bLC :: Flag
$mLC :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
LC = Flag 'L' 'C'

-- | The 'Flag' pattern used for /Liechtenstein/ denoted with /LI/.
pattern LI :: Flag
pattern $bLI :: Flag
$mLI :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
LI = Flag 'L' 'I'

-- | The 'Flag' pattern used for /Sri Lanka/ denoted with /LK/.
pattern LK :: Flag
pattern $bLK :: Flag
$mLK :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
LK = Flag 'L' 'K'

-- | The 'Flag' pattern used for /Liberia/ denoted with /LR/.
pattern LR :: Flag
pattern $bLR :: Flag
$mLR :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
LR = Flag 'L' 'R'

-- | The 'Flag' pattern used for /Lesotho/ denoted with /LS/.
pattern LS :: Flag
pattern $bLS :: Flag
$mLS :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
LS = Flag 'L' 'S'

-- | The 'Flag' pattern used for /Lithuania/ denoted with /LT/.
pattern LT :: Flag
pattern $bLT :: Flag
$mLT :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
LT = Flag 'L' 'T'

-- | The 'Flag' pattern used for /Luxembourg/ denoted with /LU/.
pattern LU :: Flag
pattern $bLU :: Flag
$mLU :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
LU = Flag 'L' 'U'

-- | The 'Flag' pattern used for /Latvia/ denoted with /LV/.
pattern LV :: Flag
pattern $bLV :: Flag
$mLV :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
LV = Flag 'L' 'V'

-- | The 'Flag' pattern used for /Libya/ denoted with /LY/.
pattern LY :: Flag
pattern $bLY :: Flag
$mLY :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
LY = Flag 'L' 'Y'

-- | The 'Flag' pattern used for /Morocco/ denoted with /MA/.
pattern MA :: Flag
pattern $bMA :: Flag
$mMA :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MA = Flag 'M' 'A'

-- | The 'Flag' pattern used for /Monaco/ denoted with /MC/.
pattern MC :: Flag
pattern $bMC :: Flag
$mMC :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MC = Flag 'M' 'C'

-- | The 'Flag' pattern used for /Moldova/ denoted with /MD/.
pattern MD :: Flag
pattern $bMD :: Flag
$mMD :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MD = Flag 'M' 'D'

-- | The 'Flag' pattern used for /Montenegro/ denoted with /ME/.
pattern ME :: Flag
pattern $bME :: Flag
$mME :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
ME = Flag 'M' 'E'

-- | The 'Flag' pattern used for /St. Martin/ denoted with /MF/.
pattern MF :: Flag
pattern $bMF :: Flag
$mMF :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MF = Flag 'M' 'F'

-- | The 'Flag' pattern used for /Madagascar/ denoted with /MG/.
pattern MG :: Flag
pattern $bMG :: Flag
$mMG :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MG = Flag 'M' 'G'

-- | The 'Flag' pattern used for the /Marshall Islands/ denoted with /MH/.
pattern MH :: Flag
pattern $bMH :: Flag
$mMH :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MH = Flag 'M' 'H'

-- | The 'Flag' pattern used for /North Macedonia/ denoted with /MK/.
pattern MK :: Flag
pattern $bMK :: Flag
$mMK :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MK = Flag 'M' 'K'

-- | The 'Flag' pattern used for /Mali/ denoted with /ML/.
pattern ML :: Flag
pattern $bML :: Flag
$mML :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
ML = Flag 'M' 'L'

-- | The 'Flag' pattern used for /Myanmar (Burma)/ denoted with /MM/.
pattern MM :: Flag
pattern $bMM :: Flag
$mMM :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MM = Flag 'M' 'M'

-- | The 'Flag' pattern used for /Mongolia/ denoted with /MN/.
pattern MN :: Flag
pattern $bMN :: Flag
$mMN :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MN = Flag 'M' 'N'

-- | The 'Flag' pattern used for /Macao SAR China/ denoted with /MO/.
pattern MO :: Flag
pattern $bMO :: Flag
$mMO :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MO = Flag 'M' 'O'

-- | The 'Flag' pattern used for the /Northern Mariana Islands/ denoted with /MP/.
pattern MP :: Flag
pattern $bMP :: Flag
$mMP :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MP = Flag 'M' 'P'

-- | The 'Flag' pattern used for /Martinique/ denoted with /MQ/.
pattern MQ :: Flag
pattern $bMQ :: Flag
$mMQ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MQ = Flag 'M' 'Q'

-- | The 'Flag' pattern used for /Mauritania/ denoted with /MR/.
pattern MR :: Flag
pattern $bMR :: Flag
$mMR :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MR = Flag 'M' 'R'

-- | The 'Flag' pattern used for /Montserrat/ denoted with /MS/.
pattern MS :: Flag
pattern $bMS :: Flag
$mMS :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MS = Flag 'M' 'S'

-- | The 'Flag' pattern used for /Malta/ denoted with /MT/.
pattern MT :: Flag
pattern $bMT :: Flag
$mMT :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MT = Flag 'M' 'T'

-- | The 'Flag' pattern used for /Mauritius/ denoted with /MU/.
pattern MU :: Flag
pattern $bMU :: Flag
$mMU :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MU = Flag 'M' 'U'

-- | The 'Flag' pattern used for the /Maldives/ denoted with /MV/.
pattern MV :: Flag
pattern $bMV :: Flag
$mMV :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MV = Flag 'M' 'V'

-- | The 'Flag' pattern used for /Malawi/ denoted with /MW/.
pattern MW :: Flag
pattern $bMW :: Flag
$mMW :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MW = Flag 'M' 'W'

-- | The 'Flag' pattern used for /Mexico/ denoted with /MX/.
pattern MX :: Flag
pattern $bMX :: Flag
$mMX :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MX = Flag 'M' 'X'

-- | The 'Flag' pattern used for /Malaysia/ denoted with /MY/.
pattern MY :: Flag
pattern $bMY :: Flag
$mMY :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MY = Flag 'M' 'Y'

-- | The 'Flag' pattern used for /Mozambique/ denoted with /MZ/.
pattern MZ :: Flag
pattern $bMZ :: Flag
$mMZ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
MZ = Flag 'M' 'Z'

-- | The 'Flag' pattern used for /Namibia/ denoted with /NA/.
pattern NA :: Flag
pattern $bNA :: Flag
$mNA :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
NA = Flag 'N' 'A'

-- | The 'Flag' pattern used for /New Caledonia/ denoted with /NC/.
pattern NC :: Flag
pattern $bNC :: Flag
$mNC :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
NC = Flag 'N' 'C'

-- | The 'Flag' pattern used for /Niger/ denoted with /NE/.
pattern NE :: Flag
pattern $bNE :: Flag
$mNE :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
NE = Flag 'N' 'E'

-- | The 'Flag' pattern used for /Norfolk Island/ denoted with /NF/.
pattern NF :: Flag
pattern $bNF :: Flag
$mNF :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
NF = Flag 'N' 'F'

-- | The 'Flag' pattern used for /Nigeria/ denoted with /NG/.
pattern NG :: Flag
pattern $bNG :: Flag
$mNG :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
NG = Flag 'N' 'G'

-- | The 'Flag' pattern used for /Nicaragua/ denoted with /NI/.
pattern NI :: Flag
pattern $bNI :: Flag
$mNI :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
NI = Flag 'N' 'I'

-- | The 'Flag' pattern used for the /Netherlands/ denoted with /NL/.
pattern NL :: Flag
pattern $bNL :: Flag
$mNL :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
NL = Flag 'N' 'L'

-- | The 'Flag' pattern used for /Norway/ denoted with /NO/.
pattern NO :: Flag
pattern $bNO :: Flag
$mNO :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
NO = Flag 'N' 'O'

-- | The 'Flag' pattern used for /Nepal/ denoted with /NP/.
pattern NP :: Flag
pattern $bNP :: Flag
$mNP :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
NP = Flag 'N' 'P'

-- | The 'Flag' pattern used for /Nauru/ denoted with /NR/.
pattern NR :: Flag
pattern $bNR :: Flag
$mNR :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
NR = Flag 'N' 'R'

-- | The 'Flag' pattern used for /Niue/ denoted with /NU/.
pattern NU :: Flag
pattern $bNU :: Flag
$mNU :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
NU = Flag 'N' 'U'

-- | The 'Flag' pattern used for /New Zealand/ denoted with /NZ/.
pattern NZ :: Flag
pattern $bNZ :: Flag
$mNZ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
NZ = Flag 'N' 'Z'

-- | The 'Flag' pattern used for /Oman/ denoted with /OM/.
pattern OM :: Flag
pattern $bOM :: Flag
$mOM :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
OM = Flag 'O' 'M'

-- | The 'Flag' pattern used for /Panama/ denoted with /PA/.
pattern PA :: Flag
pattern $bPA :: Flag
$mPA :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
PA = Flag 'P' 'A'

-- | The 'Flag' pattern used for /Peru/ denoted with /PE/.
pattern PE :: Flag
pattern $bPE :: Flag
$mPE :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
PE = Flag 'P' 'E'

-- | The 'Flag' pattern used for /French Polynesia/ denoted with /PF/.
pattern PF :: Flag
pattern $bPF :: Flag
$mPF :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
PF = Flag 'P' 'F'

-- | The 'Flag' pattern used for /Papua New Guinea/ denoted with /PG/.
pattern PG :: Flag
pattern $bPG :: Flag
$mPG :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
PG = Flag 'P' 'G'

-- | The 'Flag' pattern used for the /Philippines/ denoted with /PH/.
pattern PH :: Flag
pattern $bPH :: Flag
$mPH :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
PH = Flag 'P' 'H'

-- | The 'Flag' pattern used for /Pakistan/ denoted with /PK/.
pattern PK :: Flag
pattern $bPK :: Flag
$mPK :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
PK = Flag 'P' 'K'

-- | The 'Flag' pattern used for /Poland/ denoted with /PL/.
pattern PL :: Flag
pattern $bPL :: Flag
$mPL :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
PL = Flag 'P' 'L'

-- | The 'Flag' pattern used for /St. Pierre & Miquelon/ denoted with /PM/.
pattern PM :: Flag
pattern $bPM :: Flag
$mPM :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
PM = Flag 'P' 'M'

-- | The 'Flag' pattern used for the /Pitcairn Islands/ denoted with /PN/.
pattern PN :: Flag
pattern $bPN :: Flag
$mPN :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
PN = Flag 'P' 'N'

-- | The 'Flag' pattern used for /Puerto Rico/ denoted with /PR/.
pattern PR :: Flag
pattern $bPR :: Flag
$mPR :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
PR = Flag 'P' 'R'

-- | The 'Flag' pattern used for the /Palestinian Territories/ denoted with /PS/.
pattern PS :: Flag
pattern $bPS :: Flag
$mPS :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
PS = Flag 'P' 'S'

-- | The 'Flag' pattern used for /Portugal/ denoted with /PT/.
pattern PT :: Flag
pattern $bPT :: Flag
$mPT :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
PT = Flag 'P' 'T'

-- | The 'Flag' pattern used for /Palau/ denoted with /PW/.
pattern PW :: Flag
pattern $bPW :: Flag
$mPW :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
PW = Flag 'P' 'W'

-- | The 'Flag' pattern used for /Paraguay/ denoted with /PY/.
pattern PY :: Flag
pattern $bPY :: Flag
$mPY :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
PY = Flag 'P' 'Y'

-- | The 'Flag' pattern used for /Qatar/ denoted with /QA/.
pattern QA :: Flag
pattern $bQA :: Flag
$mQA :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
QA = Flag 'Q' 'A'

-- | The 'Flag' pattern used for /Réunion/ denoted with /RE/.
pattern RE :: Flag
pattern $bRE :: Flag
$mRE :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
RE = Flag 'R' 'E'

-- | The 'Flag' pattern used for /Romania/ denoted with /RO/.
pattern RO :: Flag
pattern $bRO :: Flag
$mRO :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
RO = Flag 'R' 'O'

-- | The 'Flag' pattern used for /Serbia/ denoted with /RS/.
pattern RS :: Flag
pattern $bRS :: Flag
$mRS :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
RS = Flag 'R' 'S'

-- | The 'Flag' pattern used for /Russia/ denoted with /RU/.
pattern RU :: Flag
pattern $bRU :: Flag
$mRU :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
RU = Flag 'R' 'U'

-- | The 'Flag' pattern used for /Rwanda/ denoted with /RW/.
pattern RW :: Flag
pattern $bRW :: Flag
$mRW :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
RW = Flag 'R' 'W'

-- | The 'Flag' pattern used for /Saudi Arabia/ denoted with /SA/.
pattern SA :: Flag
pattern $bSA :: Flag
$mSA :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SA = Flag 'S' 'A'

-- | The 'Flag' pattern used for the /Solomon Islands/ denoted with /SB/.
pattern SB :: Flag
pattern $bSB :: Flag
$mSB :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SB = Flag 'S' 'B'

-- | The 'Flag' pattern used for /Seychelles/ denoted with /SC/.
pattern SC :: Flag
pattern $bSC :: Flag
$mSC :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SC = Flag 'S' 'C'

-- | The 'Flag' pattern used for /Sudan/ denoted with /SD/.
pattern SD :: Flag
pattern $bSD :: Flag
$mSD :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SD = Flag 'S' 'D'

-- | The 'Flag' pattern used for /Sweden/ denoted with /SE/.
pattern SE :: Flag
pattern $bSE :: Flag
$mSE :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SE = Flag 'S' 'E'

-- | The 'Flag' pattern used for /Singapore/ denoted with /SG/.
pattern SG :: Flag
pattern $bSG :: Flag
$mSG :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SG = Flag 'S' 'G'

-- | The 'Flag' pattern used for /St. Helena/ denoted with /SH/.
pattern SH :: Flag
pattern $bSH :: Flag
$mSH :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SH = Flag 'S' 'H'

-- | The 'Flag' pattern used for /Slovenia/ denoted with /SI/.
pattern SI :: Flag
pattern $bSI :: Flag
$mSI :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SI = Flag 'S' 'I'

-- | The 'Flag' pattern used for /Svalbard & Jan Mayen/ denoted with /SJ/.
pattern SJ :: Flag
pattern $bSJ :: Flag
$mSJ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SJ = Flag 'S' 'J'

-- | The 'Flag' pattern used for /Slovakia/ denoted with /SK/.
pattern SK :: Flag
pattern $bSK :: Flag
$mSK :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SK = Flag 'S' 'K'

-- | The 'Flag' pattern used for /Sierra Leone/ denoted with /SL/.
pattern SL :: Flag
pattern $bSL :: Flag
$mSL :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SL = Flag 'S' 'L'

-- | The 'Flag' pattern used for /San Marino/ denoted with /SM/.
pattern SM :: Flag
pattern $bSM :: Flag
$mSM :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SM = Flag 'S' 'M'

-- | The 'Flag' pattern used for /Senegal/ denoted with /SN/.
pattern SN :: Flag
pattern $bSN :: Flag
$mSN :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SN = Flag 'S' 'N'

-- | The 'Flag' pattern used for /Somalia/ denoted with /SO/.
pattern SO :: Flag
pattern $bSO :: Flag
$mSO :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SO = Flag 'S' 'O'

-- | The 'Flag' pattern used for /Suriname/ denoted with /SR/.
pattern SR :: Flag
pattern $bSR :: Flag
$mSR :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SR = Flag 'S' 'R'

-- | The 'Flag' pattern used for /South Sudan/ denoted with /SS/.
pattern SS :: Flag
pattern $bSS :: Flag
$mSS :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SS = Flag 'S' 'S'

-- | The 'Flag' pattern used for /São Tomé & Príncipe/ denoted with /ST/.
pattern ST :: Flag
pattern $bST :: Flag
$mST :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
ST = Flag 'S' 'T'

-- | The 'Flag' pattern used for /El Salvador/ denoted with /SV/.
pattern SV :: Flag
pattern $bSV :: Flag
$mSV :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SV = Flag 'S' 'V'

-- | The 'Flag' pattern used for /Sint Maarten/ denoted with /SX/.
pattern SX :: Flag
pattern $bSX :: Flag
$mSX :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SX = Flag 'S' 'X'

-- | The 'Flag' pattern used for /Syria/ denoted with /SY/.
pattern SY :: Flag
pattern $bSY :: Flag
$mSY :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SY = Flag 'S' 'Y'

-- | The 'Flag' pattern used for /Eswatini/ denoted with /SZ/.
pattern SZ :: Flag
pattern $bSZ :: Flag
$mSZ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
SZ = Flag 'S' 'Z'

-- | The 'Flag' pattern used for /Tristan da Cunha/ denoted with /TA/.
pattern TA :: Flag
pattern $bTA :: Flag
$mTA :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
TA = Flag 'T' 'A'

-- | The 'Flag' pattern used for the /Turks & Caicos Islands/ denoted with /TC/.
pattern TC :: Flag
pattern $bTC :: Flag
$mTC :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
TC = Flag 'T' 'C'

-- | The 'Flag' pattern used for /Chad/ denoted with /TD/.
pattern TD :: Flag
pattern $bTD :: Flag
$mTD :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
TD = Flag 'T' 'D'

-- | The 'Flag' pattern used for the /French Southern Territories/ denoted with /TF/.
pattern TF :: Flag
pattern $bTF :: Flag
$mTF :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
TF = Flag 'T' 'F'

-- | The 'Flag' pattern used for /Togo/ denoted with /TG/.
pattern TG :: Flag
pattern $bTG :: Flag
$mTG :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
TG = Flag 'T' 'G'

-- | The 'Flag' pattern used for /Thailand/ denoted with /TH/.
pattern TH :: Flag
pattern $bTH :: Flag
$mTH :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
TH = Flag 'T' 'H'

-- | The 'Flag' pattern used for /Tajikistan/ denoted with /TJ/.
pattern TJ :: Flag
pattern $bTJ :: Flag
$mTJ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
TJ = Flag 'T' 'J'

-- | The 'Flag' pattern used for /Tokelau/ denoted with /TK/.
pattern TK :: Flag
pattern $bTK :: Flag
$mTK :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
TK = Flag 'T' 'K'

-- | The 'Flag' pattern used for /Timor-Leste/ denoted with /TL/.
pattern TL :: Flag
pattern $bTL :: Flag
$mTL :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
TL = Flag 'T' 'L'

-- | The 'Flag' pattern used for /Turkmenistan/ denoted with /TM/.
pattern TM :: Flag
pattern $bTM :: Flag
$mTM :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
TM = Flag 'T' 'M'

-- | The 'Flag' pattern used for /Tunisia/ denoted with /TN/.
pattern TN :: Flag
pattern $bTN :: Flag
$mTN :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
TN = Flag 'T' 'N'

-- | The 'Flag' pattern used for /Tonga/ denoted with /TO/.
pattern TO :: Flag
pattern $bTO :: Flag
$mTO :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
TO = Flag 'T' 'O'

-- | The 'Flag' pattern used for /Turkey/ denoted with /TR/.
pattern TR :: Flag
pattern $bTR :: Flag
$mTR :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
TR = Flag 'T' 'R'

-- | The 'Flag' pattern used for /Trinidad & Tobago/ denoted with /TT/.
pattern TT :: Flag
pattern $bTT :: Flag
$mTT :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
TT = Flag 'T' 'T'

-- | The 'Flag' pattern used for /Tuvalu/ denoted with /TV/.
pattern TV :: Flag
pattern $bTV :: Flag
$mTV :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
TV = Flag 'T' 'V'

-- | The 'Flag' pattern used for /Taiwan/ denoted with /TW/.
pattern TW :: Flag
pattern $bTW :: Flag
$mTW :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
TW = Flag 'T' 'W'

-- | The 'Flag' pattern used for /Tanzania/ denoted with /TZ/.
pattern TZ :: Flag
pattern $bTZ :: Flag
$mTZ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
TZ = Flag 'T' 'Z'

-- | The 'Flag' pattern used for /Ukraine/ denoted with /UA/.
pattern UA :: Flag
pattern $bUA :: Flag
$mUA :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
UA = Flag 'U' 'A'

-- | The 'Flag' pattern used for /Uganda/ denoted with /UG/.
pattern UG :: Flag
pattern $bUG :: Flag
$mUG :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
UG = Flag 'U' 'G'

-- | The 'Flag' pattern used for the /U.S. Outlying Islands/ denoted with /UM/.
pattern UM :: Flag
pattern $bUM :: Flag
$mUM :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
UM = Flag 'U' 'M'

-- | The 'Flag' pattern used for the /United Nations/ denoted with /UN/.
pattern UN :: Flag
pattern $bUN :: Flag
$mUN :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
UN = Flag 'U' 'N'

-- | The 'Flag' pattern used for the /United States/ denoted with /US/.
pattern US :: Flag
pattern $bUS :: Flag
$mUS :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
US = Flag 'U' 'S'

-- | The 'Flag' pattern used for /Uruguay/ denoted with /UY/.
pattern UY :: Flag
pattern $bUY :: Flag
$mUY :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
UY = Flag 'U' 'Y'

-- | The 'Flag' pattern used for /Uzbekistan/ denoted with /UZ/.
pattern UZ :: Flag
pattern $bUZ :: Flag
$mUZ :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
UZ = Flag 'U' 'Z'

-- | The 'Flag' pattern used for /Vatican City/ denoted with /VA/.
pattern VA :: Flag
pattern $bVA :: Flag
$mVA :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
VA = Flag 'V' 'A'

-- | The 'Flag' pattern used for /St. Vincent & Grenadines/ denoted with /VC/.
pattern VC :: Flag
pattern $bVC :: Flag
$mVC :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
VC = Flag 'V' 'C'

-- | The 'Flag' pattern used for /Venezuela/ denoted with /VE/.
pattern VE :: Flag
pattern $bVE :: Flag
$mVE :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
VE = Flag 'V' 'E'

-- | The 'Flag' pattern used for the /British Virgin Islands/ denoted with /VG/.
pattern VG :: Flag
pattern $bVG :: Flag
$mVG :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
VG = Flag 'V' 'G'

-- | The 'Flag' pattern used for the /U.S. Virgin Islands/ denoted with /VI/.
pattern VI :: Flag
pattern $bVI :: Flag
$mVI :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
VI = Flag 'V' 'I'

-- | The 'Flag' pattern used for /Vietnam/ denoted with /VN/.
pattern VN :: Flag
pattern $bVN :: Flag
$mVN :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
VN = Flag 'V' 'N'

-- | The 'Flag' pattern used for /Vanuatu/ denoted with /VU/.
pattern VU :: Flag
pattern $bVU :: Flag
$mVU :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
VU = Flag 'V' 'U'

-- | The 'Flag' pattern used for /Wallis & Futuna/ denoted with /WF/.
pattern WF :: Flag
pattern $bWF :: Flag
$mWF :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
WF = Flag 'W' 'F'

-- | The 'Flag' pattern used for /Samoa/ denoted with /WS/.
pattern WS :: Flag
pattern $bWS :: Flag
$mWS :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
WS = Flag 'W' 'S'

-- | The 'Flag' pattern used for /Kosovo/ denoted with /XK/.
pattern XK :: Flag
pattern $bXK :: Flag
$mXK :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
XK = Flag 'X' 'K'

-- | The 'Flag' pattern used for /Yemen/ denoted with /YE/.
pattern YE :: Flag
pattern $bYE :: Flag
$mYE :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
YE = Flag 'Y' 'E'

-- | The 'Flag' pattern used for /Mayotte/ denoted with /YT/.
pattern YT :: Flag
pattern $bYT :: Flag
$mYT :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
YT = Flag 'Y' 'T'

-- | The 'Flag' pattern used for /South Africa/ denoted with /ZA/.
pattern ZA :: Flag
pattern $bZA :: Flag
$mZA :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
ZA = Flag 'Z' 'A'

-- | The 'Flag' pattern used for /Zambia/ denoted with /ZM/.
pattern ZM :: Flag
pattern $bZM :: Flag
$mZM :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
ZM = Flag 'Z' 'M'

-- | The 'Flag' pattern used for /Zimbabwe/ denoted with /ZW/.
pattern ZW :: Flag
pattern $bZW :: Flag
$mZW :: forall r. Flag -> (Void# -> r) -> (Void# -> r) -> r
ZW = Flag 'Z' 'W'

-- | The 'SubFlag' pattern use for /England/ denoted with /GB-ENG/ or /ENG/.
pattern ENG :: SubFlag
pattern $bENG :: SubFlag
$mENG :: forall r. SubFlag -> (Void# -> r) -> (Void# -> r) -> r
ENG = SubFlag GB 'e' 'n' 'g'

-- | The 'SubFlag' pattern use for /Scotland/ denoted with /GB-SCT/ or /SCT/.
pattern SCT :: SubFlag
pattern $bSCT :: SubFlag
$mSCT :: forall r. SubFlag -> (Void# -> r) -> (Void# -> r) -> r
SCT = SubFlag GB 's' 'c' 't'

-- | The 'SubFlag' pattern use for /Wales/ denoted with /GB-WLS/ or /WLS/.
pattern WLS :: SubFlag
pattern $bWLS :: SubFlag
$mWLS :: forall r. SubFlag -> (Void# -> r) -> (Void# -> r) -> r
WLS = SubFlag GB 'w' 'l' 's'

instance Bounded SubFlag where
    minBound :: SubFlag
minBound = SubFlag
ENG
    maxBound :: SubFlag
maxBound = SubFlag
WLS

-- | A 'Clock' object that can be converted to a unicode character that displays
-- a clock with the given time. The 'Clock' has an 'hours' field that contains
-- the given hours between 0 and 12, and a 'minutes30' field that if 'True',
-- means that the clock is half past that hour.
data Clock = Clock {
    Clock -> Int
hours :: Int  -- ^ The number of hours on the given clock. Is between 0 and 12. For 0, the 'minutes30' is 'True'; and for 12, the 'minutes30' is 'False'.
  , Clock -> Bool
minutes30 :: Bool  -- ^ Is 'True' if it is half past the given hour on the 'Clock'.
  } deriving (Typeable Clock
DataType
Constr
Typeable Clock
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Clock -> c Clock)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Clock)
-> (Clock -> Constr)
-> (Clock -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Clock))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clock))
-> ((forall b. Data b => b -> b) -> Clock -> Clock)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clock -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clock -> r)
-> (forall u. (forall d. Data d => d -> u) -> Clock -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Clock -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Clock -> m Clock)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Clock -> m Clock)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Clock -> m Clock)
-> Data Clock
Clock -> DataType
Clock -> Constr
(forall b. Data b => b -> b) -> Clock -> Clock
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Clock -> c Clock
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Clock
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Clock -> u
forall u. (forall d. Data d => d -> u) -> Clock -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clock -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clock -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Clock -> m Clock
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Clock -> m Clock
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Clock
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Clock -> c Clock
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Clock)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clock)
$cClock :: Constr
$tClock :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Clock -> m Clock
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Clock -> m Clock
gmapMp :: (forall d. Data d => d -> m d) -> Clock -> m Clock
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Clock -> m Clock
gmapM :: (forall d. Data d => d -> m d) -> Clock -> m Clock
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Clock -> m Clock
gmapQi :: Int -> (forall d. Data d => d -> u) -> Clock -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Clock -> u
gmapQ :: (forall d. Data d => d -> u) -> Clock -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Clock -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clock -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clock -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clock -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clock -> r
gmapT :: (forall b. Data b => b -> b) -> Clock -> Clock
$cgmapT :: (forall b. Data b => b -> b) -> Clock -> Clock
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clock)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clock)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Clock)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Clock)
dataTypeOf :: Clock -> DataType
$cdataTypeOf :: Clock -> DataType
toConstr :: Clock -> Constr
$ctoConstr :: Clock -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Clock
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Clock
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Clock -> c Clock
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Clock -> c Clock
$cp1Data :: Typeable Clock
Data, Clock -> Clock -> Bool
(Clock -> Clock -> Bool) -> (Clock -> Clock -> Bool) -> Eq Clock
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Clock -> Clock -> Bool
$c/= :: Clock -> Clock -> Bool
== :: Clock -> Clock -> Bool
$c== :: Clock -> Clock -> Bool
Eq, (forall x. Clock -> Rep Clock x)
-> (forall x. Rep Clock x -> Clock) -> Generic Clock
forall x. Rep Clock x -> Clock
forall x. Clock -> Rep Clock x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Clock x -> Clock
$cfrom :: forall x. Clock -> Rep Clock x
Generic, Eq Clock
Eq Clock
-> (Clock -> Clock -> Ordering)
-> (Clock -> Clock -> Bool)
-> (Clock -> Clock -> Bool)
-> (Clock -> Clock -> Bool)
-> (Clock -> Clock -> Bool)
-> (Clock -> Clock -> Clock)
-> (Clock -> Clock -> Clock)
-> Ord Clock
Clock -> Clock -> Bool
Clock -> Clock -> Ordering
Clock -> Clock -> Clock
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Clock -> Clock -> Clock
$cmin :: Clock -> Clock -> Clock
max :: Clock -> Clock -> Clock
$cmax :: Clock -> Clock -> Clock
>= :: Clock -> Clock -> Bool
$c>= :: Clock -> Clock -> Bool
> :: Clock -> Clock -> Bool
$c> :: Clock -> Clock -> Bool
<= :: Clock -> Clock -> Bool
$c<= :: Clock -> Clock -> Bool
< :: Clock -> Clock -> Bool
$c< :: Clock -> Clock -> Bool
compare :: Clock -> Clock -> Ordering
$ccompare :: Clock -> Clock -> Ordering
$cp1Ord :: Eq Clock
Ord, ReadPrec [Clock]
ReadPrec Clock
Int -> ReadS Clock
ReadS [Clock]
(Int -> ReadS Clock)
-> ReadS [Clock]
-> ReadPrec Clock
-> ReadPrec [Clock]
-> Read Clock
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Clock]
$creadListPrec :: ReadPrec [Clock]
readPrec :: ReadPrec Clock
$creadPrec :: ReadPrec Clock
readList :: ReadS [Clock]
$creadList :: ReadS [Clock]
readsPrec :: Int -> ReadS Clock
$creadsPrec :: Int -> ReadS Clock
Read, Int -> Clock -> ShowS
[Clock] -> ShowS
Clock -> String
(Int -> Clock -> ShowS)
-> (Clock -> String) -> ([Clock] -> ShowS) -> Show Clock
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Clock] -> ShowS
$cshowList :: [Clock] -> ShowS
show :: Clock -> String
$cshow :: Clock -> String
showsPrec :: Int -> Clock -> ShowS
$cshowsPrec :: Int -> Clock -> ShowS
Show)

instance Hashable Clock

instance NFData Clock

-- | A 'BloodType' object used to convert to its unicode equivalent. The
-- 'BloodType' is also seen as a 2-bit value with the leftmost bit representing
-- the presence of /A antigens/ and the rightmost the presence of /B antigens/.
data BloodType
  = O  -- ^ The /O blood type/, with no presence of A and B antigens.
  | B  -- ^ The /B blood type/, with presence of the B antigen.
  | A  -- ^ The /A blood type/, with presence of the A antigen.
  | AB  -- ^ The /AB blood type/, with presence of the A and B antigens.
  deriving (BloodType
BloodType -> BloodType -> Bounded BloodType
forall a. a -> a -> Bounded a
maxBound :: BloodType
$cmaxBound :: BloodType
minBound :: BloodType
$cminBound :: BloodType
Bounded, Typeable BloodType
DataType
Constr
Typeable BloodType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BloodType -> c BloodType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BloodType)
-> (BloodType -> Constr)
-> (BloodType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BloodType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BloodType))
-> ((forall b. Data b => b -> b) -> BloodType -> BloodType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BloodType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BloodType -> r)
-> (forall u. (forall d. Data d => d -> u) -> BloodType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BloodType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BloodType -> m BloodType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BloodType -> m BloodType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BloodType -> m BloodType)
-> Data BloodType
BloodType -> DataType
BloodType -> Constr
(forall b. Data b => b -> b) -> BloodType -> BloodType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BloodType -> c BloodType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BloodType
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> BloodType -> u
forall u. (forall d. Data d => d -> u) -> BloodType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BloodType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BloodType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BloodType -> m BloodType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BloodType -> m BloodType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BloodType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BloodType -> c BloodType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BloodType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BloodType)
$cAB :: Constr
$cA :: Constr
$cB :: Constr
$cO :: Constr
$tBloodType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> BloodType -> m BloodType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BloodType -> m BloodType
gmapMp :: (forall d. Data d => d -> m d) -> BloodType -> m BloodType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BloodType -> m BloodType
gmapM :: (forall d. Data d => d -> m d) -> BloodType -> m BloodType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BloodType -> m BloodType
gmapQi :: Int -> (forall d. Data d => d -> u) -> BloodType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BloodType -> u
gmapQ :: (forall d. Data d => d -> u) -> BloodType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BloodType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BloodType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BloodType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BloodType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BloodType -> r
gmapT :: (forall b. Data b => b -> b) -> BloodType -> BloodType
$cgmapT :: (forall b. Data b => b -> b) -> BloodType -> BloodType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BloodType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BloodType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c BloodType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BloodType)
dataTypeOf :: BloodType -> DataType
$cdataTypeOf :: BloodType -> DataType
toConstr :: BloodType -> Constr
$ctoConstr :: BloodType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BloodType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BloodType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BloodType -> c BloodType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BloodType -> c BloodType
$cp1Data :: Typeable BloodType
Data, Int -> BloodType
BloodType -> Int
BloodType -> [BloodType]
BloodType -> BloodType
BloodType -> BloodType -> [BloodType]
BloodType -> BloodType -> BloodType -> [BloodType]
(BloodType -> BloodType)
-> (BloodType -> BloodType)
-> (Int -> BloodType)
-> (BloodType -> Int)
-> (BloodType -> [BloodType])
-> (BloodType -> BloodType -> [BloodType])
-> (BloodType -> BloodType -> [BloodType])
-> (BloodType -> BloodType -> BloodType -> [BloodType])
-> Enum BloodType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: BloodType -> BloodType -> BloodType -> [BloodType]
$cenumFromThenTo :: BloodType -> BloodType -> BloodType -> [BloodType]
enumFromTo :: BloodType -> BloodType -> [BloodType]
$cenumFromTo :: BloodType -> BloodType -> [BloodType]
enumFromThen :: BloodType -> BloodType -> [BloodType]
$cenumFromThen :: BloodType -> BloodType -> [BloodType]
enumFrom :: BloodType -> [BloodType]
$cenumFrom :: BloodType -> [BloodType]
fromEnum :: BloodType -> Int
$cfromEnum :: BloodType -> Int
toEnum :: Int -> BloodType
$ctoEnum :: Int -> BloodType
pred :: BloodType -> BloodType
$cpred :: BloodType -> BloodType
succ :: BloodType -> BloodType
$csucc :: BloodType -> BloodType
Enum, BloodType -> BloodType -> Bool
(BloodType -> BloodType -> Bool)
-> (BloodType -> BloodType -> Bool) -> Eq BloodType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BloodType -> BloodType -> Bool
$c/= :: BloodType -> BloodType -> Bool
== :: BloodType -> BloodType -> Bool
$c== :: BloodType -> BloodType -> Bool
Eq, (forall x. BloodType -> Rep BloodType x)
-> (forall x. Rep BloodType x -> BloodType) -> Generic BloodType
forall x. Rep BloodType x -> BloodType
forall x. BloodType -> Rep BloodType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BloodType x -> BloodType
$cfrom :: forall x. BloodType -> Rep BloodType x
Generic, Eq BloodType
Eq BloodType
-> (BloodType -> BloodType -> Ordering)
-> (BloodType -> BloodType -> Bool)
-> (BloodType -> BloodType -> Bool)
-> (BloodType -> BloodType -> Bool)
-> (BloodType -> BloodType -> Bool)
-> (BloodType -> BloodType -> BloodType)
-> (BloodType -> BloodType -> BloodType)
-> Ord BloodType
BloodType -> BloodType -> Bool
BloodType -> BloodType -> Ordering
BloodType -> BloodType -> BloodType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BloodType -> BloodType -> BloodType
$cmin :: BloodType -> BloodType -> BloodType
max :: BloodType -> BloodType -> BloodType
$cmax :: BloodType -> BloodType -> BloodType
>= :: BloodType -> BloodType -> Bool
$c>= :: BloodType -> BloodType -> Bool
> :: BloodType -> BloodType -> Bool
$c> :: BloodType -> BloodType -> Bool
<= :: BloodType -> BloodType -> Bool
$c<= :: BloodType -> BloodType -> Bool
< :: BloodType -> BloodType -> Bool
$c< :: BloodType -> BloodType -> Bool
compare :: BloodType -> BloodType -> Ordering
$ccompare :: BloodType -> BloodType -> Ordering
$cp1Ord :: Eq BloodType
Ord, ReadPrec [BloodType]
ReadPrec BloodType
Int -> ReadS BloodType
ReadS [BloodType]
(Int -> ReadS BloodType)
-> ReadS [BloodType]
-> ReadPrec BloodType
-> ReadPrec [BloodType]
-> Read BloodType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BloodType]
$creadListPrec :: ReadPrec [BloodType]
readPrec :: ReadPrec BloodType
$creadPrec :: ReadPrec BloodType
readList :: ReadS [BloodType]
$creadList :: ReadS [BloodType]
readsPrec :: Int -> ReadS BloodType
$creadsPrec :: Int -> ReadS BloodType
Read, Int -> BloodType -> ShowS
[BloodType] -> ShowS
BloodType -> String
(Int -> BloodType -> ShowS)
-> (BloodType -> String)
-> ([BloodType] -> ShowS)
-> Show BloodType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BloodType] -> ShowS
$cshowList :: [BloodType] -> ShowS
show :: BloodType -> String
$cshow :: BloodType -> String
showsPrec :: Int -> BloodType -> ShowS
$cshowsPrec :: Int -> BloodType -> ShowS
Show)

instance Hashable BloodType

instance NFData BloodType

_overEnumMask :: Enum a => Int -> (Int -> Int) -> a -> a
_overEnumMask :: Int -> (Int -> Int) -> a -> a
_overEnumMask Int
m Int -> Int
f = Int -> a
forall a. Enum a => Int -> a
toEnum (Int -> a) -> (a -> Int) -> a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int
m Int -> Int -> Int
forall a. Bits a => a -> a -> a
.&.) (Int -> Int) -> (a -> Int) -> a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int
f (Int -> Int) -> (a -> Int) -> a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Int
forall a. Enum a => a -> Int
fromEnum

_overEnum2 :: Enum a => (Int -> Int -> Int) -> a -> a -> a
_overEnum2 :: (Int -> Int -> Int) -> a -> a -> a
_overEnum2 Int -> Int -> Int
f a
x a
y = Int -> a
forall a. Enum a => Int -> a
toEnum ((Int -> Int -> Int) -> (a -> Int) -> a -> a -> Int
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Int -> Int -> Int
f a -> Int
forall a. Enum a => a -> Int
fromEnum a
x a
y)

_overEnumMask2 :: Enum a => Int -> (Int -> Int -> Int) -> a -> a -> a
_overEnumMask2 :: Int -> (Int -> Int -> Int) -> a -> a -> a
_overEnumMask2 Int
m Int -> Int -> Int
f a
x a
y = Int -> a
forall a. Enum a => Int -> a
toEnum (Int
m Int -> Int -> Int
forall a. Bits a => a -> a -> a
.&. (Int -> Int -> Int) -> (a -> Int) -> a -> a -> Int
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Int -> Int -> Int
f a -> Int
forall a. Enum a => a -> Int
fromEnum a
x a
y)

instance Bits BloodType where
    .&. :: BloodType -> BloodType -> BloodType
(.&.) = (Int -> Int -> Int) -> BloodType -> BloodType -> BloodType
forall a. Enum a => (Int -> Int -> Int) -> a -> a -> a
_overEnum2 Int -> Int -> Int
forall a. Bits a => a -> a -> a
(.&.)
    .|. :: BloodType -> BloodType -> BloodType
(.|.) = (Int -> Int -> Int) -> BloodType -> BloodType -> BloodType
forall a. Enum a => (Int -> Int -> Int) -> a -> a -> a
_overEnum2 Int -> Int -> Int
forall a. Bits a => a -> a -> a
(.|.)
    xor :: BloodType -> BloodType -> BloodType
xor = Int -> (Int -> Int -> Int) -> BloodType -> BloodType -> BloodType
forall a. Enum a => Int -> (Int -> Int -> Int) -> a -> a -> a
_overEnumMask2 Int
0x03 Int -> Int -> Int
forall a. Bits a => a -> a -> a
xor
    complement :: BloodType -> BloodType
complement BloodType
O = BloodType
AB
    complement BloodType
A = BloodType
B
    complement BloodType
B = BloodType
A
    complement BloodType
AB = BloodType
O
    shift :: BloodType -> Int -> BloodType
shift BloodType
abo Int
n = Int -> (Int -> Int) -> BloodType -> BloodType
forall a. Enum a => Int -> (Int -> Int) -> a -> a
_overEnumMask Int
0x03 (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
`shift` Int
n) BloodType
abo
    rotate :: BloodType -> Int -> BloodType
rotate = (Int -> BloodType -> BloodType) -> BloodType -> Int -> BloodType
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Int -> BloodType -> BloodType
forall a. (Eq a, Num a) => a -> BloodType -> BloodType
go (Int -> BloodType -> BloodType)
-> (Int -> Int) -> Int -> BloodType -> BloodType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int
0x01 Int -> Int -> Int
forall a. Bits a => a -> a -> a
.&.))
        where go :: a -> BloodType -> BloodType
go a
1 BloodType
A = BloodType
B
              go a
1 BloodType
B = BloodType
B
              go a
_ BloodType
x = BloodType
x
    bitSize :: BloodType -> Int
bitSize = Int -> BloodType -> Int
forall a b. a -> b -> a
const Int
2
    bitSizeMaybe :: BloodType -> Maybe Int
bitSizeMaybe = Maybe Int -> BloodType -> Maybe Int
forall a b. a -> b -> a
const (Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)
    isSigned :: BloodType -> Bool
isSigned = Bool -> BloodType -> Bool
forall a b. a -> b -> a
const Bool
False
    testBit :: BloodType -> Int -> Bool
testBit = Int -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit (Int -> Int -> Bool)
-> (BloodType -> Int) -> BloodType -> Int -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BloodType -> Int
forall a. Enum a => a -> Int
fromEnum
    bit :: Int -> BloodType
bit Int
0 = BloodType
B
    bit Int
1 = BloodType
A
    bit Int
_ = BloodType
O
    popCount :: BloodType -> Int
popCount BloodType
O = Int
0
    popCount BloodType
A = Int
1
    popCount BloodType
B = Int
1
    popCount BloodType
AB = Int
2

instance Bounded Clock where
    minBound :: Clock
minBound = Int -> Bool -> Clock
Clock Int
0 Bool
True
    maxBound :: Clock
maxBound = Int -> Bool -> Clock
Clock Int
12 Bool
False

instance Enum Clock where
    fromEnum :: Clock -> Int
fromEnum (Clock Int
h Bool
m30) = Int -> Int
forall a. Enum a => a -> a
pred (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
shiftL Int
h Int
1 Int -> Int -> Int
forall a. Bits a => a -> a -> a
.|. Int -> Int -> Bool -> Int
forall a. a -> a -> Bool -> a
bool Int
0 Int
1 Bool
m30)
    toEnum :: Int -> Clock
toEnum Int
hm30
        | Int
hm30 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 Bool -> Bool -> Bool
|| Int
hm30 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
23 = String -> Int -> (Clock, Clock) -> Clock
forall a b. Show a => String -> Int -> (a, a) -> b
toEnumError String
"Clock" Int
hm30 (Clock
forall a. Bounded a => a
minBound :: Clock, Clock
forall a. Bounded a => a
maxBound)
        | Bool
otherwise = Int -> Bool -> Clock
Clock (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
shiftR Int
hm30' Int
1) (Int -> Bool
forall a. Integral a => a -> Bool
odd Int
hm30')
        where hm30' :: Int
hm30' = Int -> Int
forall a. Enum a => a -> a
succ Int
hm30
    enumFrom :: Clock -> [Clock]
enumFrom = (Clock -> Clock -> [Clock]
forall a. Enum a => a -> a -> [a]
`enumFromTo` Clock
forall a. Bounded a => a
maxBound)
    enumFromThen :: Clock -> Clock -> [Clock]
enumFromThen Clock
x Clock
y = Clock -> Clock -> Clock -> [Clock]
forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo Clock
x Clock
y Clock
forall a. Bounded a => a
maxBound

-- | Generate the 'Clock' object that is the closest to the given hours and
-- minutes.
closestClock
  :: Int  -- ^ The number of hours.
  -> Int  -- ^ The number of minutes, must be between 0 and 60.
  -> Clock  -- ^ The clock object that is the closest to the given hours and minutes.
closestClock :: Int -> Int -> Clock
closestClock Int
h Int
m
    | Int
m Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
15 = Int -> Bool -> Clock
clock Int
h Bool
False
    | Int
m Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
45 = Int -> Bool -> Clock
clock Int
h Bool
True
    | Bool
otherwise = Int -> Bool -> Clock
clock (Int
hInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) Bool
False

-- | Construct a 'Clock' object with the given number of hours, and a 'Bool'ean
-- that indicates if it is half past that hour.
-- The function will ensure that the hours are between 0 and 12 (both inclusive).
-- For half past 12, we use half past 0, for 12 hours, we use simply 12.
clock
  :: Int  -- ^ The given hour of the clock, can be any value, but will be set between 1 and 12.
  -> Bool  -- ^ A 'Bool'ean that indicates if it is half past that hour, so 'True' means we add 30 minutes.
  -> Clock  -- ^ A clock object that represents the time that is passed through an hour and .
clock :: Int -> Bool -> Clock
clock Int
h Bool
b
    | Bool
b Bool -> Bool -> Bool
&& Int
h' Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
12 = Int -> Bool -> Clock
Clock Int
0 Bool
True
    | Bool
otherwise = Int -> Bool -> Clock
Clock Int
h' Bool
b
    where h' :: Int
h' = Int -> Int -> Int
forall a. Integral a => a -> a -> a
mod (Int
hInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1) Int
12 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1

-- | A data type to specify the /gender/ of a person, animal, etc. used in an
-- emoji. The 'Gender' items are an instance of 'UnicodeText' that maps to the
-- /female/ and /male/ emoji.
data Gender
  = Female -- The female sign, dented by ♀️.
  | Male  -- The male sign, denoted by ♂️.
  deriving (Gender
Gender -> Gender -> Bounded Gender
forall a. a -> a -> Bounded a
maxBound :: Gender
$cmaxBound :: Gender
minBound :: Gender
$cminBound :: Gender
Bounded, Typeable Gender
DataType
Constr
Typeable Gender
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Gender -> c Gender)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Gender)
-> (Gender -> Constr)
-> (Gender -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Gender))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Gender))
-> ((forall b. Data b => b -> b) -> Gender -> Gender)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Gender -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Gender -> r)
-> (forall u. (forall d. Data d => d -> u) -> Gender -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Gender -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Gender -> m Gender)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Gender -> m Gender)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Gender -> m Gender)
-> Data Gender
Gender -> DataType
Gender -> Constr
(forall b. Data b => b -> b) -> Gender -> Gender
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Gender -> c Gender
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Gender
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Gender -> u
forall u. (forall d. Data d => d -> u) -> Gender -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Gender -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Gender -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Gender -> m Gender
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Gender -> m Gender
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Gender
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Gender -> c Gender
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Gender)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Gender)
$cMale :: Constr
$cFemale :: Constr
$tGender :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Gender -> m Gender
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Gender -> m Gender
gmapMp :: (forall d. Data d => d -> m d) -> Gender -> m Gender
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Gender -> m Gender
gmapM :: (forall d. Data d => d -> m d) -> Gender -> m Gender
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Gender -> m Gender
gmapQi :: Int -> (forall d. Data d => d -> u) -> Gender -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Gender -> u
gmapQ :: (forall d. Data d => d -> u) -> Gender -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Gender -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Gender -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Gender -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Gender -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Gender -> r
gmapT :: (forall b. Data b => b -> b) -> Gender -> Gender
$cgmapT :: (forall b. Data b => b -> b) -> Gender -> Gender
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Gender)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Gender)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Gender)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Gender)
dataTypeOf :: Gender -> DataType
$cdataTypeOf :: Gender -> DataType
toConstr :: Gender -> Constr
$ctoConstr :: Gender -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Gender
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Gender
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Gender -> c Gender
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Gender -> c Gender
$cp1Data :: Typeable Gender
Data, Int -> Gender
Gender -> Int
Gender -> [Gender]
Gender -> Gender
Gender -> Gender -> [Gender]
Gender -> Gender -> Gender -> [Gender]
(Gender -> Gender)
-> (Gender -> Gender)
-> (Int -> Gender)
-> (Gender -> Int)
-> (Gender -> [Gender])
-> (Gender -> Gender -> [Gender])
-> (Gender -> Gender -> [Gender])
-> (Gender -> Gender -> Gender -> [Gender])
-> Enum Gender
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Gender -> Gender -> Gender -> [Gender]
$cenumFromThenTo :: Gender -> Gender -> Gender -> [Gender]
enumFromTo :: Gender -> Gender -> [Gender]
$cenumFromTo :: Gender -> Gender -> [Gender]
enumFromThen :: Gender -> Gender -> [Gender]
$cenumFromThen :: Gender -> Gender -> [Gender]
enumFrom :: Gender -> [Gender]
$cenumFrom :: Gender -> [Gender]
fromEnum :: Gender -> Int
$cfromEnum :: Gender -> Int
toEnum :: Int -> Gender
$ctoEnum :: Int -> Gender
pred :: Gender -> Gender
$cpred :: Gender -> Gender
succ :: Gender -> Gender
$csucc :: Gender -> Gender
Enum, Gender -> Gender -> Bool
(Gender -> Gender -> Bool)
-> (Gender -> Gender -> Bool) -> Eq Gender
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Gender -> Gender -> Bool
$c/= :: Gender -> Gender -> Bool
== :: Gender -> Gender -> Bool
$c== :: Gender -> Gender -> Bool
Eq, (forall x. Gender -> Rep Gender x)
-> (forall x. Rep Gender x -> Gender) -> Generic Gender
forall x. Rep Gender x -> Gender
forall x. Gender -> Rep Gender x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Gender x -> Gender
$cfrom :: forall x. Gender -> Rep Gender x
Generic, Eq Gender
Eq Gender
-> (Gender -> Gender -> Ordering)
-> (Gender -> Gender -> Bool)
-> (Gender -> Gender -> Bool)
-> (Gender -> Gender -> Bool)
-> (Gender -> Gender -> Bool)
-> (Gender -> Gender -> Gender)
-> (Gender -> Gender -> Gender)
-> Ord Gender
Gender -> Gender -> Bool
Gender -> Gender -> Ordering
Gender -> Gender -> Gender
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Gender -> Gender -> Gender
$cmin :: Gender -> Gender -> Gender
max :: Gender -> Gender -> Gender
$cmax :: Gender -> Gender -> Gender
>= :: Gender -> Gender -> Bool
$c>= :: Gender -> Gender -> Bool
> :: Gender -> Gender -> Bool
$c> :: Gender -> Gender -> Bool
<= :: Gender -> Gender -> Bool
$c<= :: Gender -> Gender -> Bool
< :: Gender -> Gender -> Bool
$c< :: Gender -> Gender -> Bool
compare :: Gender -> Gender -> Ordering
$ccompare :: Gender -> Gender -> Ordering
$cp1Ord :: Eq Gender
Ord, ReadPrec [Gender]
ReadPrec Gender
Int -> ReadS Gender
ReadS [Gender]
(Int -> ReadS Gender)
-> ReadS [Gender]
-> ReadPrec Gender
-> ReadPrec [Gender]
-> Read Gender
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Gender]
$creadListPrec :: ReadPrec [Gender]
readPrec :: ReadPrec Gender
$creadPrec :: ReadPrec Gender
readList :: ReadS [Gender]
$creadList :: ReadS [Gender]
readsPrec :: Int -> ReadS Gender
$creadsPrec :: Int -> ReadS Gender
Read, Int -> Gender -> ShowS
[Gender] -> ShowS
Gender -> String
(Int -> Gender -> ShowS)
-> (Gender -> String) -> ([Gender] -> ShowS) -> Show Gender
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Gender] -> ShowS
$cshowList :: [Gender] -> ShowS
show :: Gender -> String
$cshow :: Gender -> String
showsPrec :: Int -> Gender -> ShowS
$cshowsPrec :: Int -> Gender -> ShowS
Show)

instance Hashable Gender

instance NFData Gender

-- | Some emoji deal with people. One can change the color of the skin with the
-- 'SkinColorModifier'. For the skin color, the <https://en.wikipedia.org/wiki/Fitzpatrick_scale /Fitzpatrick scale/> is used.
-- A numerical classification system for skin types.
data SkinColorModifier
  = Light  -- ^ An emoji /modifier/ that applies /Fitzpatrick skin type/ one or two to the Emoji.
  | MediumLight  -- ^ An emoji /modifier/ that applies /Fitzpatrick skin type/ three to the Emoji.
  | Medium  -- ^ An emoji /modifier/ that applies /Fitzpatrick skin type/ four to the Emoji.
  | MediumDark  -- ^ An emoji /modifier/ that applies /Fitzpatrick skin type/ five to the Emoji.
  | Dark  -- ^ An emoji /modifier/ that applies /Fitzpatrick skin type/ six to the Emoji.
  deriving (SkinColorModifier
SkinColorModifier -> SkinColorModifier -> Bounded SkinColorModifier
forall a. a -> a -> Bounded a
maxBound :: SkinColorModifier
$cmaxBound :: SkinColorModifier
minBound :: SkinColorModifier
$cminBound :: SkinColorModifier
Bounded, Typeable SkinColorModifier
DataType
Constr
Typeable SkinColorModifier
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> SkinColorModifier
    -> c SkinColorModifier)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SkinColorModifier)
-> (SkinColorModifier -> Constr)
-> (SkinColorModifier -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SkinColorModifier))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SkinColorModifier))
-> ((forall b. Data b => b -> b)
    -> SkinColorModifier -> SkinColorModifier)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SkinColorModifier -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SkinColorModifier -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SkinColorModifier -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SkinColorModifier -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SkinColorModifier -> m SkinColorModifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SkinColorModifier -> m SkinColorModifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SkinColorModifier -> m SkinColorModifier)
-> Data SkinColorModifier
SkinColorModifier -> DataType
SkinColorModifier -> Constr
(forall b. Data b => b -> b)
-> SkinColorModifier -> SkinColorModifier
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SkinColorModifier -> c SkinColorModifier
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SkinColorModifier
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> SkinColorModifier -> u
forall u. (forall d. Data d => d -> u) -> SkinColorModifier -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SkinColorModifier -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SkinColorModifier -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SkinColorModifier -> m SkinColorModifier
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SkinColorModifier -> m SkinColorModifier
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SkinColorModifier
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SkinColorModifier -> c SkinColorModifier
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SkinColorModifier)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SkinColorModifier)
$cDark :: Constr
$cMediumDark :: Constr
$cMedium :: Constr
$cMediumLight :: Constr
$cLight :: Constr
$tSkinColorModifier :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> SkinColorModifier -> m SkinColorModifier
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SkinColorModifier -> m SkinColorModifier
gmapMp :: (forall d. Data d => d -> m d)
-> SkinColorModifier -> m SkinColorModifier
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SkinColorModifier -> m SkinColorModifier
gmapM :: (forall d. Data d => d -> m d)
-> SkinColorModifier -> m SkinColorModifier
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SkinColorModifier -> m SkinColorModifier
gmapQi :: Int -> (forall d. Data d => d -> u) -> SkinColorModifier -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SkinColorModifier -> u
gmapQ :: (forall d. Data d => d -> u) -> SkinColorModifier -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SkinColorModifier -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SkinColorModifier -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SkinColorModifier -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SkinColorModifier -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SkinColorModifier -> r
gmapT :: (forall b. Data b => b -> b)
-> SkinColorModifier -> SkinColorModifier
$cgmapT :: (forall b. Data b => b -> b)
-> SkinColorModifier -> SkinColorModifier
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SkinColorModifier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SkinColorModifier)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SkinColorModifier)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SkinColorModifier)
dataTypeOf :: SkinColorModifier -> DataType
$cdataTypeOf :: SkinColorModifier -> DataType
toConstr :: SkinColorModifier -> Constr
$ctoConstr :: SkinColorModifier -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SkinColorModifier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SkinColorModifier
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SkinColorModifier -> c SkinColorModifier
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SkinColorModifier -> c SkinColorModifier
$cp1Data :: Typeable SkinColorModifier
Data, Int -> SkinColorModifier
SkinColorModifier -> Int
SkinColorModifier -> [SkinColorModifier]
SkinColorModifier -> SkinColorModifier
SkinColorModifier -> SkinColorModifier -> [SkinColorModifier]
SkinColorModifier
-> SkinColorModifier -> SkinColorModifier -> [SkinColorModifier]
(SkinColorModifier -> SkinColorModifier)
-> (SkinColorModifier -> SkinColorModifier)
-> (Int -> SkinColorModifier)
-> (SkinColorModifier -> Int)
-> (SkinColorModifier -> [SkinColorModifier])
-> (SkinColorModifier -> SkinColorModifier -> [SkinColorModifier])
-> (SkinColorModifier -> SkinColorModifier -> [SkinColorModifier])
-> (SkinColorModifier
    -> SkinColorModifier -> SkinColorModifier -> [SkinColorModifier])
-> Enum SkinColorModifier
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: SkinColorModifier
-> SkinColorModifier -> SkinColorModifier -> [SkinColorModifier]
$cenumFromThenTo :: SkinColorModifier
-> SkinColorModifier -> SkinColorModifier -> [SkinColorModifier]
enumFromTo :: SkinColorModifier -> SkinColorModifier -> [SkinColorModifier]
$cenumFromTo :: SkinColorModifier -> SkinColorModifier -> [SkinColorModifier]
enumFromThen :: SkinColorModifier -> SkinColorModifier -> [SkinColorModifier]
$cenumFromThen :: SkinColorModifier -> SkinColorModifier -> [SkinColorModifier]
enumFrom :: SkinColorModifier -> [SkinColorModifier]
$cenumFrom :: SkinColorModifier -> [SkinColorModifier]
fromEnum :: SkinColorModifier -> Int
$cfromEnum :: SkinColorModifier -> Int
toEnum :: Int -> SkinColorModifier
$ctoEnum :: Int -> SkinColorModifier
pred :: SkinColorModifier -> SkinColorModifier
$cpred :: SkinColorModifier -> SkinColorModifier
succ :: SkinColorModifier -> SkinColorModifier
$csucc :: SkinColorModifier -> SkinColorModifier
Enum, SkinColorModifier -> SkinColorModifier -> Bool
(SkinColorModifier -> SkinColorModifier -> Bool)
-> (SkinColorModifier -> SkinColorModifier -> Bool)
-> Eq SkinColorModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SkinColorModifier -> SkinColorModifier -> Bool
$c/= :: SkinColorModifier -> SkinColorModifier -> Bool
== :: SkinColorModifier -> SkinColorModifier -> Bool
$c== :: SkinColorModifier -> SkinColorModifier -> Bool
Eq, (forall x. SkinColorModifier -> Rep SkinColorModifier x)
-> (forall x. Rep SkinColorModifier x -> SkinColorModifier)
-> Generic SkinColorModifier
forall x. Rep SkinColorModifier x -> SkinColorModifier
forall x. SkinColorModifier -> Rep SkinColorModifier x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SkinColorModifier x -> SkinColorModifier
$cfrom :: forall x. SkinColorModifier -> Rep SkinColorModifier x
Generic, Eq SkinColorModifier
Eq SkinColorModifier
-> (SkinColorModifier -> SkinColorModifier -> Ordering)
-> (SkinColorModifier -> SkinColorModifier -> Bool)
-> (SkinColorModifier -> SkinColorModifier -> Bool)
-> (SkinColorModifier -> SkinColorModifier -> Bool)
-> (SkinColorModifier -> SkinColorModifier -> Bool)
-> (SkinColorModifier -> SkinColorModifier -> SkinColorModifier)
-> (SkinColorModifier -> SkinColorModifier -> SkinColorModifier)
-> Ord SkinColorModifier
SkinColorModifier -> SkinColorModifier -> Bool
SkinColorModifier -> SkinColorModifier -> Ordering
SkinColorModifier -> SkinColorModifier -> SkinColorModifier
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SkinColorModifier -> SkinColorModifier -> SkinColorModifier
$cmin :: SkinColorModifier -> SkinColorModifier -> SkinColorModifier
max :: SkinColorModifier -> SkinColorModifier -> SkinColorModifier
$cmax :: SkinColorModifier -> SkinColorModifier -> SkinColorModifier
>= :: SkinColorModifier -> SkinColorModifier -> Bool
$c>= :: SkinColorModifier -> SkinColorModifier -> Bool
> :: SkinColorModifier -> SkinColorModifier -> Bool
$c> :: SkinColorModifier -> SkinColorModifier -> Bool
<= :: SkinColorModifier -> SkinColorModifier -> Bool
$c<= :: SkinColorModifier -> SkinColorModifier -> Bool
< :: SkinColorModifier -> SkinColorModifier -> Bool
$c< :: SkinColorModifier -> SkinColorModifier -> Bool
compare :: SkinColorModifier -> SkinColorModifier -> Ordering
$ccompare :: SkinColorModifier -> SkinColorModifier -> Ordering
$cp1Ord :: Eq SkinColorModifier
Ord, ReadPrec [SkinColorModifier]
ReadPrec SkinColorModifier
Int -> ReadS SkinColorModifier
ReadS [SkinColorModifier]
(Int -> ReadS SkinColorModifier)
-> ReadS [SkinColorModifier]
-> ReadPrec SkinColorModifier
-> ReadPrec [SkinColorModifier]
-> Read SkinColorModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SkinColorModifier]
$creadListPrec :: ReadPrec [SkinColorModifier]
readPrec :: ReadPrec SkinColorModifier
$creadPrec :: ReadPrec SkinColorModifier
readList :: ReadS [SkinColorModifier]
$creadList :: ReadS [SkinColorModifier]
readsPrec :: Int -> ReadS SkinColorModifier
$creadsPrec :: Int -> ReadS SkinColorModifier
Read, Int -> SkinColorModifier -> ShowS
[SkinColorModifier] -> ShowS
SkinColorModifier -> String
(Int -> SkinColorModifier -> ShowS)
-> (SkinColorModifier -> String)
-> ([SkinColorModifier] -> ShowS)
-> Show SkinColorModifier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SkinColorModifier] -> ShowS
$cshowList :: [SkinColorModifier] -> ShowS
show :: SkinColorModifier -> String
$cshow :: SkinColorModifier -> String
showsPrec :: Int -> SkinColorModifier -> ShowS
$cshowsPrec :: Int -> SkinColorModifier -> ShowS
Show)

instance Hashable SkinColorModifier

instance NFData SkinColorModifier

-- | A data type to deal with the /zodiac sign/ emoji. The data type lists the
-- different zodiac signs as data constructors, and the instance of the
-- 'UnicodeCharacter' allows to convert it from and to a 'Char'acter.
data Zodiac
  = Aries  -- ^ The /aries/ zodiac sign, /ram/ in English, is denoted as ♈.
  | Taurus  -- ^ The /taurus/ zodiac sign, /bull/ in English, is denoted as ♉.
  | Gemini  -- ^ The /gemini/ zodiac sign, /twins/ in English, is denoted as ♊.
  | Cancer  -- ^ The /cancer/ zodiac sign, /crab/ in English, is denoted as ♋.
  | Leo  -- ^ The /leo/ zodiac sign, /lion/ in English, is denoted as ♌.
  | Virgo  -- ^ The /virgo/ zodiac sign, /maiden/ in English, is denoted as ♍.
  | Libra  -- ^ The /libra/ zodiac sign, /scales/ in English, is denoted as ♎.
  | Scorpio  -- ^ The /scorpio/ zodiac sign, /scorpion/ in English, is denoted as ♏.
  | Sagittarius  -- ^ The /saggitarius/ zodiac sign, /archer/ in English, is denoted as ♐.
  | Capricorn  -- ^ The /capricorn/ zodiac sign, /sea-goat/ in English, is denoted as ♑.
  | Aquarius  -- ^ The /aquarius/ zodiac sign, /water-bearer/ in English, is denoted as ♒.
  | Pisces  -- ^ The /pices/ zodiac sign, /fish/ in English, is denoted as ♓.
  deriving (Zodiac
Zodiac -> Zodiac -> Bounded Zodiac
forall a. a -> a -> Bounded a
maxBound :: Zodiac
$cmaxBound :: Zodiac
minBound :: Zodiac
$cminBound :: Zodiac
Bounded, Typeable Zodiac
DataType
Constr
Typeable Zodiac
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Zodiac -> c Zodiac)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Zodiac)
-> (Zodiac -> Constr)
-> (Zodiac -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Zodiac))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Zodiac))
-> ((forall b. Data b => b -> b) -> Zodiac -> Zodiac)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Zodiac -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Zodiac -> r)
-> (forall u. (forall d. Data d => d -> u) -> Zodiac -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Zodiac -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Zodiac -> m Zodiac)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Zodiac -> m Zodiac)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Zodiac -> m Zodiac)
-> Data Zodiac
Zodiac -> DataType
Zodiac -> Constr
(forall b. Data b => b -> b) -> Zodiac -> Zodiac
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Zodiac -> c Zodiac
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Zodiac
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Zodiac -> u
forall u. (forall d. Data d => d -> u) -> Zodiac -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Zodiac -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Zodiac -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Zodiac -> m Zodiac
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Zodiac -> m Zodiac
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Zodiac
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Zodiac -> c Zodiac
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Zodiac)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Zodiac)
$cPisces :: Constr
$cAquarius :: Constr
$cCapricorn :: Constr
$cSagittarius :: Constr
$cScorpio :: Constr
$cLibra :: Constr
$cVirgo :: Constr
$cLeo :: Constr
$cCancer :: Constr
$cGemini :: Constr
$cTaurus :: Constr
$cAries :: Constr
$tZodiac :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Zodiac -> m Zodiac
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Zodiac -> m Zodiac
gmapMp :: (forall d. Data d => d -> m d) -> Zodiac -> m Zodiac
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Zodiac -> m Zodiac
gmapM :: (forall d. Data d => d -> m d) -> Zodiac -> m Zodiac
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Zodiac -> m Zodiac
gmapQi :: Int -> (forall d. Data d => d -> u) -> Zodiac -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Zodiac -> u
gmapQ :: (forall d. Data d => d -> u) -> Zodiac -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Zodiac -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Zodiac -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Zodiac -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Zodiac -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Zodiac -> r
gmapT :: (forall b. Data b => b -> b) -> Zodiac -> Zodiac
$cgmapT :: (forall b. Data b => b -> b) -> Zodiac -> Zodiac
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Zodiac)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Zodiac)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Zodiac)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Zodiac)
dataTypeOf :: Zodiac -> DataType
$cdataTypeOf :: Zodiac -> DataType
toConstr :: Zodiac -> Constr
$ctoConstr :: Zodiac -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Zodiac
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Zodiac
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Zodiac -> c Zodiac
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Zodiac -> c Zodiac
$cp1Data :: Typeable Zodiac
Data, Int -> Zodiac
Zodiac -> Int
Zodiac -> [Zodiac]
Zodiac -> Zodiac
Zodiac -> Zodiac -> [Zodiac]
Zodiac -> Zodiac -> Zodiac -> [Zodiac]
(Zodiac -> Zodiac)
-> (Zodiac -> Zodiac)
-> (Int -> Zodiac)
-> (Zodiac -> Int)
-> (Zodiac -> [Zodiac])
-> (Zodiac -> Zodiac -> [Zodiac])
-> (Zodiac -> Zodiac -> [Zodiac])
-> (Zodiac -> Zodiac -> Zodiac -> [Zodiac])
-> Enum Zodiac
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Zodiac -> Zodiac -> Zodiac -> [Zodiac]
$cenumFromThenTo :: Zodiac -> Zodiac -> Zodiac -> [Zodiac]
enumFromTo :: Zodiac -> Zodiac -> [Zodiac]
$cenumFromTo :: Zodiac -> Zodiac -> [Zodiac]
enumFromThen :: Zodiac -> Zodiac -> [Zodiac]
$cenumFromThen :: Zodiac -> Zodiac -> [Zodiac]
enumFrom :: Zodiac -> [Zodiac]
$cenumFrom :: Zodiac -> [Zodiac]
fromEnum :: Zodiac -> Int
$cfromEnum :: Zodiac -> Int
toEnum :: Int -> Zodiac
$ctoEnum :: Int -> Zodiac
pred :: Zodiac -> Zodiac
$cpred :: Zodiac -> Zodiac
succ :: Zodiac -> Zodiac
$csucc :: Zodiac -> Zodiac
Enum, Zodiac -> Zodiac -> Bool
(Zodiac -> Zodiac -> Bool)
-> (Zodiac -> Zodiac -> Bool) -> Eq Zodiac
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Zodiac -> Zodiac -> Bool
$c/= :: Zodiac -> Zodiac -> Bool
== :: Zodiac -> Zodiac -> Bool
$c== :: Zodiac -> Zodiac -> Bool
Eq, (forall x. Zodiac -> Rep Zodiac x)
-> (forall x. Rep Zodiac x -> Zodiac) -> Generic Zodiac
forall x. Rep Zodiac x -> Zodiac
forall x. Zodiac -> Rep Zodiac x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Zodiac x -> Zodiac
$cfrom :: forall x. Zodiac -> Rep Zodiac x
Generic, Eq Zodiac
Eq Zodiac
-> (Zodiac -> Zodiac -> Ordering)
-> (Zodiac -> Zodiac -> Bool)
-> (Zodiac -> Zodiac -> Bool)
-> (Zodiac -> Zodiac -> Bool)
-> (Zodiac -> Zodiac -> Bool)
-> (Zodiac -> Zodiac -> Zodiac)
-> (Zodiac -> Zodiac -> Zodiac)
-> Ord Zodiac
Zodiac -> Zodiac -> Bool
Zodiac -> Zodiac -> Ordering
Zodiac -> Zodiac -> Zodiac
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Zodiac -> Zodiac -> Zodiac
$cmin :: Zodiac -> Zodiac -> Zodiac
max :: Zodiac -> Zodiac -> Zodiac
$cmax :: Zodiac -> Zodiac -> Zodiac
>= :: Zodiac -> Zodiac -> Bool
$c>= :: Zodiac -> Zodiac -> Bool
> :: Zodiac -> Zodiac -> Bool
$c> :: Zodiac -> Zodiac -> Bool
<= :: Zodiac -> Zodiac -> Bool
$c<= :: Zodiac -> Zodiac -> Bool
< :: Zodiac -> Zodiac -> Bool
$c< :: Zodiac -> Zodiac -> Bool
compare :: Zodiac -> Zodiac -> Ordering
$ccompare :: Zodiac -> Zodiac -> Ordering
$cp1Ord :: Eq Zodiac
Ord, ReadPrec [Zodiac]
ReadPrec Zodiac
Int -> ReadS Zodiac
ReadS [Zodiac]
(Int -> ReadS Zodiac)
-> ReadS [Zodiac]
-> ReadPrec Zodiac
-> ReadPrec [Zodiac]
-> Read Zodiac
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Zodiac]
$creadListPrec :: ReadPrec [Zodiac]
readPrec :: ReadPrec Zodiac
$creadPrec :: ReadPrec Zodiac
readList :: ReadS [Zodiac]
$creadList :: ReadS [Zodiac]
readsPrec :: Int -> ReadS Zodiac
$creadsPrec :: Int -> ReadS Zodiac
Read, Int -> Zodiac -> ShowS
[Zodiac] -> ShowS
Zodiac -> String
(Int -> Zodiac -> ShowS)
-> (Zodiac -> String) -> ([Zodiac] -> ShowS) -> Show Zodiac
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Zodiac] -> ShowS
$cshowList :: [Zodiac] -> ShowS
show :: Zodiac -> String
$cshow :: Zodiac -> String
showsPrec :: Int -> Zodiac -> ShowS
$cshowsPrec :: Int -> Zodiac -> ShowS
Show)

instance Hashable Zodiac

instance NFData Zodiac

-- | A data type that defines the eight different moon phases, and is an
-- instance of 'UnicodeCharacter' to convert these to the corresponding Unicode
-- character.
data MoonPhase
  = NewMoon  -- ^ The /new moon/, the first phase of the moon represented by 🌑.
  | WaxingCrescent  -- ^ The /waxing crescent/, the second phase of the moon represented by 🌒.
  | FirstQuarter  -- ^ The /first quarter/, the third phase of the moon represented by 🌓.
  | WaxingGibbous  -- ^ The /waxing gibbous/, the fourth phase of the moon represented by 🌔.
  | FullMoon  -- ^ The /full moon/, the fifth phase of the moon represented by 🌕.
  | WaningGibbous  -- ^ The /waning gibbous/, the sixth phase of the moon represented by 🌖.
  | ThirdQuarter  -- ^ The /third quarter/, the seventh phase of the moon represented by 🌗.
  | WaningCrescent  -- ^ The /waning crescent/, the eighth phase of the moon represented by 🌘.
  deriving (MoonPhase
MoonPhase -> MoonPhase -> Bounded MoonPhase
forall a. a -> a -> Bounded a
maxBound :: MoonPhase
$cmaxBound :: MoonPhase
minBound :: MoonPhase
$cminBound :: MoonPhase
Bounded, Typeable MoonPhase
DataType
Constr
Typeable MoonPhase
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MoonPhase -> c MoonPhase)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MoonPhase)
-> (MoonPhase -> Constr)
-> (MoonPhase -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MoonPhase))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MoonPhase))
-> ((forall b. Data b => b -> b) -> MoonPhase -> MoonPhase)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MoonPhase -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MoonPhase -> r)
-> (forall u. (forall d. Data d => d -> u) -> MoonPhase -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MoonPhase -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MoonPhase -> m MoonPhase)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MoonPhase -> m MoonPhase)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MoonPhase -> m MoonPhase)
-> Data MoonPhase
MoonPhase -> DataType
MoonPhase -> Constr
(forall b. Data b => b -> b) -> MoonPhase -> MoonPhase
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MoonPhase -> c MoonPhase
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MoonPhase
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> MoonPhase -> u
forall u. (forall d. Data d => d -> u) -> MoonPhase -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MoonPhase -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MoonPhase -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MoonPhase -> m MoonPhase
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MoonPhase -> m MoonPhase
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MoonPhase
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MoonPhase -> c MoonPhase
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MoonPhase)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MoonPhase)
$cWaningCrescent :: Constr
$cThirdQuarter :: Constr
$cWaningGibbous :: Constr
$cFullMoon :: Constr
$cWaxingGibbous :: Constr
$cFirstQuarter :: Constr
$cWaxingCrescent :: Constr
$cNewMoon :: Constr
$tMoonPhase :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> MoonPhase -> m MoonPhase
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MoonPhase -> m MoonPhase
gmapMp :: (forall d. Data d => d -> m d) -> MoonPhase -> m MoonPhase
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MoonPhase -> m MoonPhase
gmapM :: (forall d. Data d => d -> m d) -> MoonPhase -> m MoonPhase
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MoonPhase -> m MoonPhase
gmapQi :: Int -> (forall d. Data d => d -> u) -> MoonPhase -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MoonPhase -> u
gmapQ :: (forall d. Data d => d -> u) -> MoonPhase -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MoonPhase -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MoonPhase -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MoonPhase -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MoonPhase -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MoonPhase -> r
gmapT :: (forall b. Data b => b -> b) -> MoonPhase -> MoonPhase
$cgmapT :: (forall b. Data b => b -> b) -> MoonPhase -> MoonPhase
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MoonPhase)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MoonPhase)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c MoonPhase)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MoonPhase)
dataTypeOf :: MoonPhase -> DataType
$cdataTypeOf :: MoonPhase -> DataType
toConstr :: MoonPhase -> Constr
$ctoConstr :: MoonPhase -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MoonPhase
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MoonPhase
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MoonPhase -> c MoonPhase
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MoonPhase -> c MoonPhase
$cp1Data :: Typeable MoonPhase
Data, Int -> MoonPhase
MoonPhase -> Int
MoonPhase -> [MoonPhase]
MoonPhase -> MoonPhase
MoonPhase -> MoonPhase -> [MoonPhase]
MoonPhase -> MoonPhase -> MoonPhase -> [MoonPhase]
(MoonPhase -> MoonPhase)
-> (MoonPhase -> MoonPhase)
-> (Int -> MoonPhase)
-> (MoonPhase -> Int)
-> (MoonPhase -> [MoonPhase])
-> (MoonPhase -> MoonPhase -> [MoonPhase])
-> (MoonPhase -> MoonPhase -> [MoonPhase])
-> (MoonPhase -> MoonPhase -> MoonPhase -> [MoonPhase])
-> Enum MoonPhase
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: MoonPhase -> MoonPhase -> MoonPhase -> [MoonPhase]
$cenumFromThenTo :: MoonPhase -> MoonPhase -> MoonPhase -> [MoonPhase]
enumFromTo :: MoonPhase -> MoonPhase -> [MoonPhase]
$cenumFromTo :: MoonPhase -> MoonPhase -> [MoonPhase]
enumFromThen :: MoonPhase -> MoonPhase -> [MoonPhase]
$cenumFromThen :: MoonPhase -> MoonPhase -> [MoonPhase]
enumFrom :: MoonPhase -> [MoonPhase]
$cenumFrom :: MoonPhase -> [MoonPhase]
fromEnum :: MoonPhase -> Int
$cfromEnum :: MoonPhase -> Int
toEnum :: Int -> MoonPhase
$ctoEnum :: Int -> MoonPhase
pred :: MoonPhase -> MoonPhase
$cpred :: MoonPhase -> MoonPhase
succ :: MoonPhase -> MoonPhase
$csucc :: MoonPhase -> MoonPhase
Enum, MoonPhase -> MoonPhase -> Bool
(MoonPhase -> MoonPhase -> Bool)
-> (MoonPhase -> MoonPhase -> Bool) -> Eq MoonPhase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MoonPhase -> MoonPhase -> Bool
$c/= :: MoonPhase -> MoonPhase -> Bool
== :: MoonPhase -> MoonPhase -> Bool
$c== :: MoonPhase -> MoonPhase -> Bool
Eq, (forall x. MoonPhase -> Rep MoonPhase x)
-> (forall x. Rep MoonPhase x -> MoonPhase) -> Generic MoonPhase
forall x. Rep MoonPhase x -> MoonPhase
forall x. MoonPhase -> Rep MoonPhase x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MoonPhase x -> MoonPhase
$cfrom :: forall x. MoonPhase -> Rep MoonPhase x
Generic, Eq MoonPhase
Eq MoonPhase
-> (MoonPhase -> MoonPhase -> Ordering)
-> (MoonPhase -> MoonPhase -> Bool)
-> (MoonPhase -> MoonPhase -> Bool)
-> (MoonPhase -> MoonPhase -> Bool)
-> (MoonPhase -> MoonPhase -> Bool)
-> (MoonPhase -> MoonPhase -> MoonPhase)
-> (MoonPhase -> MoonPhase -> MoonPhase)
-> Ord MoonPhase
MoonPhase -> MoonPhase -> Bool
MoonPhase -> MoonPhase -> Ordering
MoonPhase -> MoonPhase -> MoonPhase
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MoonPhase -> MoonPhase -> MoonPhase
$cmin :: MoonPhase -> MoonPhase -> MoonPhase
max :: MoonPhase -> MoonPhase -> MoonPhase
$cmax :: MoonPhase -> MoonPhase -> MoonPhase
>= :: MoonPhase -> MoonPhase -> Bool
$c>= :: MoonPhase -> MoonPhase -> Bool
> :: MoonPhase -> MoonPhase -> Bool
$c> :: MoonPhase -> MoonPhase -> Bool
<= :: MoonPhase -> MoonPhase -> Bool
$c<= :: MoonPhase -> MoonPhase -> Bool
< :: MoonPhase -> MoonPhase -> Bool
$c< :: MoonPhase -> MoonPhase -> Bool
compare :: MoonPhase -> MoonPhase -> Ordering
$ccompare :: MoonPhase -> MoonPhase -> Ordering
$cp1Ord :: Eq MoonPhase
Ord, ReadPrec [MoonPhase]
ReadPrec MoonPhase
Int -> ReadS MoonPhase
ReadS [MoonPhase]
(Int -> ReadS MoonPhase)
-> ReadS [MoonPhase]
-> ReadPrec MoonPhase
-> ReadPrec [MoonPhase]
-> Read MoonPhase
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MoonPhase]
$creadListPrec :: ReadPrec [MoonPhase]
readPrec :: ReadPrec MoonPhase
$creadPrec :: ReadPrec MoonPhase
readList :: ReadS [MoonPhase]
$creadList :: ReadS [MoonPhase]
readsPrec :: Int -> ReadS MoonPhase
$creadsPrec :: Int -> ReadS MoonPhase
Read, Int -> MoonPhase -> ShowS
[MoonPhase] -> ShowS
MoonPhase -> String
(Int -> MoonPhase -> ShowS)
-> (MoonPhase -> String)
-> ([MoonPhase] -> ShowS)
-> Show MoonPhase
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MoonPhase] -> ShowS
$cshowList :: [MoonPhase] -> ShowS
show :: MoonPhase -> String
$cshow :: MoonPhase -> String
showsPrec :: Int -> MoonPhase -> ShowS
$cshowsPrec :: Int -> MoonPhase -> ShowS
Show)

instance Hashable MoonPhase

instance MirrorVertical MoonPhase where
  mirrorVertical :: MoonPhase -> MoonPhase
mirrorVertical = Int -> MoonPhase
forall a. Enum a => Int -> a
toEnum (Int -> MoonPhase) -> (MoonPhase -> Int) -> MoonPhase -> MoonPhase
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Int -> Int
forall a. Integral a => a -> a -> a
`mod` Int
8) (Int -> Int) -> (MoonPhase -> Int) -> MoonPhase -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int
8 Int -> Int -> Int
forall a. Num a => a -> a -> a
-) (Int -> Int) -> (MoonPhase -> Int) -> MoonPhase -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MoonPhase -> Int
forall a. Enum a => a -> Int
fromEnum

instance NFData MoonPhase

-- | The 'SkinColorModifier' that corresponds to type one of the /Fitzpatrick
-- scale/.
pattern FitzPatrickI :: SkinColorModifier
pattern $bFitzPatrickI :: SkinColorModifier
$mFitzPatrickI :: forall r. SkinColorModifier -> (Void# -> r) -> (Void# -> r) -> r
FitzPatrickI = Light

-- | The 'SkinColorModifier' that corresponds to type two of the /Fitzpatrick
-- scale/.
pattern FitzPatrickII :: SkinColorModifier
pattern $bFitzPatrickII :: SkinColorModifier
$mFitzPatrickII :: forall r. SkinColorModifier -> (Void# -> r) -> (Void# -> r) -> r
FitzPatrickII = Light

-- | The 'SkinColorModifier' that corresponds to type three of the /Fitzpatrick
-- scale/.
pattern FitzPatrickIII :: SkinColorModifier
pattern $bFitzPatrickIII :: SkinColorModifier
$mFitzPatrickIII :: forall r. SkinColorModifier -> (Void# -> r) -> (Void# -> r) -> r
FitzPatrickIII = MediumLight

-- | The 'SkinColorModifier' that corresponds to type four of the /Fitzpatrick
-- scale/.
pattern FitzPatrickIV :: SkinColorModifier
pattern $bFitzPatrickIV :: SkinColorModifier
$mFitzPatrickIV :: forall r. SkinColorModifier -> (Void# -> r) -> (Void# -> r) -> r
FitzPatrickIV = Medium

-- | The 'SkinColorModifier' that corresponds to type five of the /Fitzpatrick
-- scale/.
pattern FitzPatrickV :: SkinColorModifier
pattern $bFitzPatrickV :: SkinColorModifier
$mFitzPatrickV :: forall r. SkinColorModifier -> (Void# -> r) -> (Void# -> r) -> r
FitzPatrickV = MediumDark

-- | The 'SkinColorModifier' that corresponds to type six of the /Fitzpatrick
-- scale/.
pattern FitzPatrickVI :: SkinColorModifier
pattern $bFitzPatrickVI :: SkinColorModifier
$mFitzPatrickVI :: forall r. SkinColorModifier -> (Void# -> r) -> (Void# -> r) -> r
FitzPatrickVI = Dark

-- | Convert the given /Fitzpatrick skin type/ to the corresponding
-- 'SkinColorModifier' wrapped in a 'Just', if no such 'SkinColorModifier'
-- exists, 'Nothing' is returned.
fromFitzPatrick :: Integral i
  => i  -- ^ The given /Fitzpatrick skin type/.
  -> Maybe SkinColorModifier  -- ^ The corresponding 'SkinColorModifier' wrapped in a 'Just'; 'Nothing' if no such modifier exists.
fromFitzPatrick :: i -> Maybe SkinColorModifier
fromFitzPatrick i
1 = SkinColorModifier -> Maybe SkinColorModifier
forall a. a -> Maybe a
Just SkinColorModifier
Light
fromFitzPatrick i
2 = SkinColorModifier -> Maybe SkinColorModifier
forall a. a -> Maybe a
Just SkinColorModifier
Light
fromFitzPatrick i
3 = SkinColorModifier -> Maybe SkinColorModifier
forall a. a -> Maybe a
Just SkinColorModifier
MediumLight
fromFitzPatrick i
4 = SkinColorModifier -> Maybe SkinColorModifier
forall a. a -> Maybe a
Just SkinColorModifier
Medium
fromFitzPatrick i
5 = SkinColorModifier -> Maybe SkinColorModifier
forall a. a -> Maybe a
Just SkinColorModifier
MediumDark
fromFitzPatrick i
6 = SkinColorModifier -> Maybe SkinColorModifier
forall a. a -> Maybe a
Just SkinColorModifier
Dark
fromFitzPatrick i
_ = Maybe SkinColorModifier
forall a. Maybe a
Nothing

-- | The English name for the 'Aries' zodiac sign.
pattern Ram :: Zodiac
pattern $bRam :: Zodiac
$mRam :: forall r. Zodiac -> (Void# -> r) -> (Void# -> r) -> r
Ram = Aries

-- | The English name for the 'Taurus' zodiac sign.
pattern Bull :: Zodiac
pattern $bBull :: Zodiac
$mBull :: forall r. Zodiac -> (Void# -> r) -> (Void# -> r) -> r
Bull = Taurus

-- | The English name for the 'Gemini' zodiac sign.
pattern Twins :: Zodiac
pattern $bTwins :: Zodiac
$mTwins :: forall r. Zodiac -> (Void# -> r) -> (Void# -> r) -> r
Twins = Gemini

-- | The English name for the 'Cancer' zodiac sign.
pattern Crab :: Zodiac
pattern $bCrab :: Zodiac
$mCrab :: forall r. Zodiac -> (Void# -> r) -> (Void# -> r) -> r
Crab = Cancer

-- | The English name for the 'Leo' zodiac sign.
pattern Lion :: Zodiac
pattern $bLion :: Zodiac
$mLion :: forall r. Zodiac -> (Void# -> r) -> (Void# -> r) -> r
Lion = Leo

-- | The English name for the 'Virgo' zodiac sign.
pattern Maiden :: Zodiac
pattern $bMaiden :: Zodiac
$mMaiden :: forall r. Zodiac -> (Void# -> r) -> (Void# -> r) -> r
Maiden = Virgo

-- | The English name for the 'Libra' zodiac sign.
pattern Scales :: Zodiac
pattern $bScales :: Zodiac
$mScales :: forall r. Zodiac -> (Void# -> r) -> (Void# -> r) -> r
Scales = Libra

-- | The name of the constellation of the 'Scorpio' zodiac sign.
pattern Scorpius :: Zodiac
pattern $bScorpius :: Zodiac
$mScorpius :: forall r. Zodiac -> (Void# -> r) -> (Void# -> r) -> r
Scorpius = Scorpio

-- | The English name for the 'Scorpio' zodiac sign.
pattern Scorpion :: Zodiac
pattern $bScorpion :: Zodiac
$mScorpion :: forall r. Zodiac -> (Void# -> r) -> (Void# -> r) -> r
Scorpion = Scorpio

-- | An English name for the 'Sagittarius' zodiac sign.
pattern Centaur :: Zodiac
pattern $bCentaur :: Zodiac
$mCentaur :: forall r. Zodiac -> (Void# -> r) -> (Void# -> r) -> r
Centaur = Sagittarius

-- | An English name for the 'Sagittarius' zodiac sign.
pattern Archer :: Zodiac
pattern $bArcher :: Zodiac
$mArcher :: forall r. Zodiac -> (Void# -> r) -> (Void# -> r) -> r
Archer = Sagittarius

-- | The name of the constellation of the 'Capricorn' zodiac sign.
pattern Capricornus :: Zodiac
pattern $bCapricornus :: Zodiac
$mCapricornus :: forall r. Zodiac -> (Void# -> r) -> (Void# -> r) -> r
Capricornus = Capricorn

-- | An English name for the 'Capricorn' zodiac sign.
pattern MountainGoat :: Zodiac
pattern $bMountainGoat :: Zodiac
$mMountainGoat :: forall r. Zodiac -> (Void# -> r) -> (Void# -> r) -> r
MountainGoat = Capricorn

-- | An English name for the 'Capricorn' zodiac sign.
pattern GoatHorned :: Zodiac
pattern $bGoatHorned :: Zodiac
$mGoatHorned :: forall r. Zodiac -> (Void# -> r) -> (Void# -> r) -> r
GoatHorned = Capricorn

-- | An English name for the 'Capricorn' zodiac sign.
pattern SeaGoat :: Zodiac
pattern $bSeaGoat :: Zodiac
$mSeaGoat :: forall r. Zodiac -> (Void# -> r) -> (Void# -> r) -> r
SeaGoat = Capricorn

-- | The English name for the 'Aquarius' zodiac sign.
pattern WaterBearer :: Zodiac
pattern $bWaterBearer :: Zodiac
$mWaterBearer :: forall r. Zodiac -> (Void# -> r) -> (Void# -> r) -> r
WaterBearer = Aquarius

-- | The English name for the 'Pisces' zodiac sign.
pattern Fish :: Zodiac
pattern $bFish :: Zodiac
$mFish :: forall r. Zodiac -> (Void# -> r) -> (Void# -> r) -> r
Fish = Pisces

_flagCharOffset :: Int
_flagCharOffset :: Int
_flagCharOffset = Int
0x1f1a5

-- | Convert the given two 'Char'acters of the ISO3166-1 Alpha-2 standard to an
-- Emoji that renders the flag of the corresponding country or terroitory.
-- Deprecated regions, such as SU (Soviet Union) and YU (Yugoslavia) have no
-- flag. The European Union (EU), Antarctica (AQ) and United Nations (UN)
-- are included as marcoregion flags. This function does not check if the
-- two characters map to a valid flag token.
iso3166Alpha2ToFlag'
  :: Char  -- ^ The first 'Char'acter of the ISO3166 Alpha-2 code.
  -> Char  -- ^ The second 'Char'acter of the ISO3166 Alpha-2 code.
  -> Text  -- ^ A 'Text' object that consists of two characters, where the two characters form a flag emoji, if the given flag exists.
iso3166Alpha2ToFlag' :: Char -> Char -> Text
iso3166Alpha2ToFlag' Char
ca Char
cb = String -> Text
pack ((Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map (Char -> Char
regionalIndicatorUppercase' (Char -> Char) -> (Char -> Char) -> Char -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char
toUpper) [Char
ca, Char
cb])

-- | Convert the given two 'Char'acters of the ISO3166-1 Alpha-2 standard to an
-- Emoji that renders the flag of the corresponding country or terroitory
-- wrapped in a 'Just' data constructor. Deprecated regions, such as SU
-- (Soviet Union) and YU (Yugoslavia) have no flag. The European Union (EU),
-- Antarctica (AQ) and United Nations (UN) are included as marcoregion flags.
-- If the flag does not exists, 'Nothing' is returned.
iso3166Alpha2ToFlag
  :: Char  -- ^ The first 'Char'acter of the ISO3166 Alpha-2 code.
  -> Char  -- ^ The second 'Char'acter of the ISO3166 Alpha-2 code.
  -> Maybe Text  -- ^ A 'Text' object that consists of two characters, where the two characters form a flag emoji wrapped in a 'Just', if the given flag exists; 'Nothing' otherwise.
iso3166Alpha2ToFlag :: Char -> Char -> Maybe Text
iso3166Alpha2ToFlag Char
ca Char
cb
  | Char -> Char -> Bool
validFlagEmoji Char
ca Char
cb = Text -> Maybe Text
forall a. a -> Maybe a
Just (Char -> Char -> Text
iso3166Alpha2ToFlag' Char
ca Char
cb)
  | Bool
otherwise = Maybe Text
forall a. Maybe a
Nothing

-- | Convert the given 'Text' object to its equivalent 'Flag' object wrapped in
-- a 'Just' data constructor if it exists; 'Nothing' otherwise.
fromFlag :: Text -> Maybe Flag
fromFlag :: Text -> Maybe Flag
fromFlag Text
t
    | [Char
a', Char
b'] <- Text -> String
unpack Text
t, Just Char
a <- Char -> Maybe Char
shft Char
a', Just Char
b <- Char -> Maybe Char
shft Char
b', Char -> Char -> Bool
_validFlagEmoji Char
a Char
b = Flag -> Maybe Flag
forall a. a -> Maybe a
Just (Char -> Char -> Flag
Flag Char
a Char
b)
    | Bool
otherwise = Maybe Flag
forall a. Maybe a
Nothing
    where shft :: Char -> Maybe Char
shft = Int -> Char -> Maybe Char
forall a. (Bounded a, Enum a) => Int -> Char -> Maybe a
mapToEnumSafe Int
_flagCharOffset

-- | Check if for the given two 'Char'acters, a flag emoji exists. The two
-- character combinations for which a flag exist are defined in the ISO3166-1
-- Alpha-2 standard where deprecated reagions, such as SU and YU have no flag,
-- and the European Union (EU), Antarctica (AQ), and the United Nations (UN)
-- have a flag. The characters can be upper case (@A-Z@) or lower case (@a-z@).
validFlagEmoji
  :: Char  -- ^ The first 'Char'acter of the ISO3166 Alpha-2 code.
  -> Char  -- ^ The second 'Char'acter of the ISO3166 Alpha-2 code.
  -> Bool  -- ^ 'True' if a flag emoji exists for the given characters; 'False' otherwise.
validFlagEmoji :: Char -> Char -> Bool
validFlagEmoji = (Char -> Char -> Bool) -> (Char -> Char) -> Char -> Char -> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Char -> Char -> Bool
_validFlagEmoji Char -> Char
toUpper

_validFlagEmoji :: Char -> Char -> Bool
_validFlagEmoji :: Char -> Char -> Bool
_validFlagEmoji Char
'A' Char
'C' = Bool
True
_validFlagEmoji Char
'A' Char
'D' = Bool
True
_validFlagEmoji Char
'A' Char
'E' = Bool
True
_validFlagEmoji Char
'A' Char
'F' = Bool
True
_validFlagEmoji Char
'A' Char
'G' = Bool
True
_validFlagEmoji Char
'A' Char
'I' = Bool
True
_validFlagEmoji Char
'A' Char
'L' = Bool
True
_validFlagEmoji Char
'A' Char
'M' = Bool
True
_validFlagEmoji Char
'A' Char
'O' = Bool
True
_validFlagEmoji Char
'A' Char
'Q' = Bool
True
_validFlagEmoji Char
'A' Char
'R' = Bool
True
_validFlagEmoji Char
'A' Char
'S' = Bool
True
_validFlagEmoji Char
'A' Char
'T' = Bool
True
_validFlagEmoji Char
'A' Char
'U' = Bool
True
_validFlagEmoji Char
'A' Char
'W' = Bool
True
_validFlagEmoji Char
'A' Char
'X' = Bool
True
_validFlagEmoji Char
'A' Char
'Z' = Bool
True
_validFlagEmoji Char
'B' Char
'A' = Bool
True
_validFlagEmoji Char
'B' Char
'B' = Bool
True
_validFlagEmoji Char
'B' Char
'D' = Bool
True
_validFlagEmoji Char
'B' Char
'E' = Bool
True
_validFlagEmoji Char
'B' Char
'F' = Bool
True
_validFlagEmoji Char
'B' Char
'G' = Bool
True
_validFlagEmoji Char
'B' Char
'H' = Bool
True
_validFlagEmoji Char
'B' Char
'I' = Bool
True
_validFlagEmoji Char
'B' Char
'J' = Bool
True
_validFlagEmoji Char
'B' Char
'L' = Bool
True
_validFlagEmoji Char
'B' Char
'M' = Bool
True
_validFlagEmoji Char
'B' Char
'N' = Bool
True
_validFlagEmoji Char
'B' Char
'O' = Bool
True
_validFlagEmoji Char
'B' Char
'Q' = Bool
True
_validFlagEmoji Char
'B' Char
'R' = Bool
True
_validFlagEmoji Char
'B' Char
'S' = Bool
True
_validFlagEmoji Char
'B' Char
'T' = Bool
True
_validFlagEmoji Char
'B' Char
'V' = Bool
True
_validFlagEmoji Char
'B' Char
'W' = Bool
True
_validFlagEmoji Char
'B' Char
'Y' = Bool
True
_validFlagEmoji Char
'B' Char
'Z' = Bool
True
_validFlagEmoji Char
'C' Char
'A' = Bool
True
_validFlagEmoji Char
'C' Char
'C' = Bool
True
_validFlagEmoji Char
'C' Char
'D' = Bool
True
_validFlagEmoji Char
'C' Char
'F' = Bool
True
_validFlagEmoji Char
'C' Char
'G' = Bool
True
_validFlagEmoji Char
'C' Char
'H' = Bool
True
_validFlagEmoji Char
'C' Char
'I' = Bool
True
_validFlagEmoji Char
'C' Char
'K' = Bool
True
_validFlagEmoji Char
'C' Char
'L' = Bool
True
_validFlagEmoji Char
'C' Char
'M' = Bool
True
_validFlagEmoji Char
'C' Char
'N' = Bool
True
_validFlagEmoji Char
'C' Char
'O' = Bool
True
_validFlagEmoji Char
'C' Char
'P' = Bool
True
_validFlagEmoji Char
'C' Char
'R' = Bool
True
_validFlagEmoji Char
'C' Char
'U' = Bool
True
_validFlagEmoji Char
'C' Char
'V' = Bool
True
_validFlagEmoji Char
'C' Char
'W' = Bool
True
_validFlagEmoji Char
'C' Char
'X' = Bool
True
_validFlagEmoji Char
'C' Char
'Y' = Bool
True
_validFlagEmoji Char
'C' Char
'Z' = Bool
True
_validFlagEmoji Char
'D' Char
'E' = Bool
True
_validFlagEmoji Char
'D' Char
'G' = Bool
True
_validFlagEmoji Char
'D' Char
'J' = Bool
True
_validFlagEmoji Char
'D' Char
'K' = Bool
True
_validFlagEmoji Char
'D' Char
'M' = Bool
True
_validFlagEmoji Char
'D' Char
'O' = Bool
True
_validFlagEmoji Char
'D' Char
'Z' = Bool
True
_validFlagEmoji Char
'E' Char
'A' = Bool
True
_validFlagEmoji Char
'E' Char
'C' = Bool
True
_validFlagEmoji Char
'E' Char
'E' = Bool
True
_validFlagEmoji Char
'E' Char
'G' = Bool
True
_validFlagEmoji Char
'E' Char
'H' = Bool
True
_validFlagEmoji Char
'E' Char
'R' = Bool
True
_validFlagEmoji Char
'E' Char
'S' = Bool
True
_validFlagEmoji Char
'E' Char
'T' = Bool
True
_validFlagEmoji Char
'E' Char
'U' = Bool
True
_validFlagEmoji Char
'F' Char
'I' = Bool
True
_validFlagEmoji Char
'F' Char
'J' = Bool
True
_validFlagEmoji Char
'F' Char
'K' = Bool
True
_validFlagEmoji Char
'F' Char
'M' = Bool
True
_validFlagEmoji Char
'F' Char
'O' = Bool
True
_validFlagEmoji Char
'F' Char
'R' = Bool
True
_validFlagEmoji Char
'G' Char
'A' = Bool
True
_validFlagEmoji Char
'G' Char
'B' = Bool
True
_validFlagEmoji Char
'G' Char
'D' = Bool
True
_validFlagEmoji Char
'G' Char
'E' = Bool
True
_validFlagEmoji Char
'G' Char
'F' = Bool
True
_validFlagEmoji Char
'G' Char
'G' = Bool
True
_validFlagEmoji Char
'G' Char
'H' = Bool
True
_validFlagEmoji Char
'G' Char
'I' = Bool
True
_validFlagEmoji Char
'G' Char
'L' = Bool
True
_validFlagEmoji Char
'G' Char
'M' = Bool
True
_validFlagEmoji Char
'G' Char
'N' = Bool
True
_validFlagEmoji Char
'G' Char
'P' = Bool
True
_validFlagEmoji Char
'G' Char
'Q' = Bool
True
_validFlagEmoji Char
'G' Char
'R' = Bool
True
_validFlagEmoji Char
'G' Char
'S' = Bool
True
_validFlagEmoji Char
'G' Char
'T' = Bool
True
_validFlagEmoji Char
'G' Char
'U' = Bool
True
_validFlagEmoji Char
'G' Char
'W' = Bool
True
_validFlagEmoji Char
'G' Char
'Y' = Bool
True
_validFlagEmoji Char
'H' Char
'K' = Bool
True
_validFlagEmoji Char
'H' Char
'M' = Bool
True
_validFlagEmoji Char
'H' Char
'N' = Bool
True
_validFlagEmoji Char
'H' Char
'R' = Bool
True
_validFlagEmoji Char
'H' Char
'T' = Bool
True
_validFlagEmoji Char
'H' Char
'U' = Bool
True
_validFlagEmoji Char
'I' Char
'C' = Bool
True
_validFlagEmoji Char
'I' Char
'D' = Bool
True
_validFlagEmoji Char
'I' Char
'E' = Bool
True
_validFlagEmoji Char
'I' Char
'L' = Bool
True
_validFlagEmoji Char
'I' Char
'M' = Bool
True
_validFlagEmoji Char
'I' Char
'N' = Bool
True
_validFlagEmoji Char
'I' Char
'O' = Bool
True
_validFlagEmoji Char
'I' Char
'Q' = Bool
True
_validFlagEmoji Char
'I' Char
'R' = Bool
True
_validFlagEmoji Char
'I' Char
'S' = Bool
True
_validFlagEmoji Char
'I' Char
'T' = Bool
True
_validFlagEmoji Char
'J' Char
'E' = Bool
True
_validFlagEmoji Char
'J' Char
'M' = Bool
True
_validFlagEmoji Char
'J' Char
'O' = Bool
True
_validFlagEmoji Char
'J' Char
'P' = Bool
True
_validFlagEmoji Char
'K' Char
'E' = Bool
True
_validFlagEmoji Char
'K' Char
'G' = Bool
True
_validFlagEmoji Char
'K' Char
'H' = Bool
True
_validFlagEmoji Char
'K' Char
'I' = Bool
True
_validFlagEmoji Char
'K' Char
'M' = Bool
True
_validFlagEmoji Char
'K' Char
'N' = Bool
True
_validFlagEmoji Char
'K' Char
'P' = Bool
True
_validFlagEmoji Char
'K' Char
'R' = Bool
True
_validFlagEmoji Char
'K' Char
'W' = Bool
True
_validFlagEmoji Char
'K' Char
'Y' = Bool
True
_validFlagEmoji Char
'K' Char
'Z' = Bool
True
_validFlagEmoji Char
'L' Char
'A' = Bool
True
_validFlagEmoji Char
'L' Char
'B' = Bool
True
_validFlagEmoji Char
'L' Char
'C' = Bool
True
_validFlagEmoji Char
'L' Char
'I' = Bool
True
_validFlagEmoji Char
'L' Char
'K' = Bool
True
_validFlagEmoji Char
'L' Char
'R' = Bool
True
_validFlagEmoji Char
'L' Char
'S' = Bool
True
_validFlagEmoji Char
'L' Char
'T' = Bool
True
_validFlagEmoji Char
'L' Char
'U' = Bool
True
_validFlagEmoji Char
'L' Char
'V' = Bool
True
_validFlagEmoji Char
'L' Char
'Y' = Bool
True
_validFlagEmoji Char
'M' Char
'A' = Bool
True
_validFlagEmoji Char
'M' Char
'C' = Bool
True
_validFlagEmoji Char
'M' Char
'D' = Bool
True
_validFlagEmoji Char
'M' Char
'E' = Bool
True
_validFlagEmoji Char
'M' Char
'F' = Bool
True
_validFlagEmoji Char
'M' Char
'G' = Bool
True
_validFlagEmoji Char
'M' Char
'H' = Bool
True
_validFlagEmoji Char
'M' Char
'K' = Bool
True
_validFlagEmoji Char
'M' Char
'L' = Bool
True
_validFlagEmoji Char
'M' Char
'M' = Bool
True
_validFlagEmoji Char
'M' Char
'N' = Bool
True
_validFlagEmoji Char
'M' Char
'O' = Bool
True
_validFlagEmoji Char
'M' Char
'P' = Bool
True
_validFlagEmoji Char
'M' Char
'Q' = Bool
True
_validFlagEmoji Char
'M' Char
'R' = Bool
True
_validFlagEmoji Char
'M' Char
'S' = Bool
True
_validFlagEmoji Char
'M' Char
'T' = Bool
True
_validFlagEmoji Char
'M' Char
'U' = Bool
True
_validFlagEmoji Char
'M' Char
'V' = Bool
True
_validFlagEmoji Char
'M' Char
'W' = Bool
True
_validFlagEmoji Char
'M' Char
'X' = Bool
True
_validFlagEmoji Char
'M' Char
'Y' = Bool
True
_validFlagEmoji Char
'M' Char
'Z' = Bool
True
_validFlagEmoji Char
'N' Char
'A' = Bool
True
_validFlagEmoji Char
'N' Char
'C' = Bool
True
_validFlagEmoji Char
'N' Char
'E' = Bool
True
_validFlagEmoji Char
'N' Char
'F' = Bool
True
_validFlagEmoji Char
'N' Char
'G' = Bool
True
_validFlagEmoji Char
'N' Char
'I' = Bool
True
_validFlagEmoji Char
'N' Char
'L' = Bool
True
_validFlagEmoji Char
'N' Char
'O' = Bool
True
_validFlagEmoji Char
'N' Char
'P' = Bool
True
_validFlagEmoji Char
'N' Char
'R' = Bool
True
_validFlagEmoji Char
'N' Char
'U' = Bool
True
_validFlagEmoji Char
'N' Char
'Z' = Bool
True
_validFlagEmoji Char
'O' Char
'M' = Bool
True
_validFlagEmoji Char
'P' Char
'A' = Bool
True
_validFlagEmoji Char
'P' Char
'E' = Bool
True
_validFlagEmoji Char
'P' Char
'F' = Bool
True
_validFlagEmoji Char
'P' Char
'G' = Bool
True
_validFlagEmoji Char
'P' Char
'H' = Bool
True
_validFlagEmoji Char
'P' Char
'K' = Bool
True
_validFlagEmoji Char
'P' Char
'L' = Bool
True
_validFlagEmoji Char
'P' Char
'M' = Bool
True
_validFlagEmoji Char
'P' Char
'N' = Bool
True
_validFlagEmoji Char
'P' Char
'R' = Bool
True
_validFlagEmoji Char
'P' Char
'S' = Bool
True
_validFlagEmoji Char
'P' Char
'T' = Bool
True
_validFlagEmoji Char
'P' Char
'W' = Bool
True
_validFlagEmoji Char
'P' Char
'Y' = Bool
True
_validFlagEmoji Char
'Q' Char
'A' = Bool
True
_validFlagEmoji Char
'R' Char
'E' = Bool
True
_validFlagEmoji Char
'R' Char
'O' = Bool
True
_validFlagEmoji Char
'R' Char
'S' = Bool
True
_validFlagEmoji Char
'R' Char
'U' = Bool
True
_validFlagEmoji Char
'R' Char
'W' = Bool
True
_validFlagEmoji Char
'S' Char
'A' = Bool
True
_validFlagEmoji Char
'S' Char
'B' = Bool
True
_validFlagEmoji Char
'S' Char
'C' = Bool
True
_validFlagEmoji Char
'S' Char
'D' = Bool
True
_validFlagEmoji Char
'S' Char
'E' = Bool
True
_validFlagEmoji Char
'S' Char
'G' = Bool
True
_validFlagEmoji Char
'S' Char
'H' = Bool
True
_validFlagEmoji Char
'S' Char
'I' = Bool
True
_validFlagEmoji Char
'S' Char
'J' = Bool
True
_validFlagEmoji Char
'S' Char
'K' = Bool
True
_validFlagEmoji Char
'S' Char
'L' = Bool
True
_validFlagEmoji Char
'S' Char
'M' = Bool
True
_validFlagEmoji Char
'S' Char
'N' = Bool
True
_validFlagEmoji Char
'S' Char
'O' = Bool
True
_validFlagEmoji Char
'S' Char
'R' = Bool
True
_validFlagEmoji Char
'S' Char
'S' = Bool
True
_validFlagEmoji Char
'S' Char
'T' = Bool
True
_validFlagEmoji Char
'S' Char
'V' = Bool
True
_validFlagEmoji Char
'S' Char
'X' = Bool
True
_validFlagEmoji Char
'S' Char
'Y' = Bool
True
_validFlagEmoji Char
'S' Char
'Z' = Bool
True
_validFlagEmoji Char
'T' Char
'A' = Bool
True
_validFlagEmoji Char
'T' Char
'C' = Bool
True
_validFlagEmoji Char
'T' Char
'D' = Bool
True
_validFlagEmoji Char
'T' Char
'F' = Bool
True
_validFlagEmoji Char
'T' Char
'G' = Bool
True
_validFlagEmoji Char
'T' Char
'H' = Bool
True
_validFlagEmoji Char
'T' Char
'J' = Bool
True
_validFlagEmoji Char
'T' Char
'K' = Bool
True
_validFlagEmoji Char
'T' Char
'L' = Bool
True
_validFlagEmoji Char
'T' Char
'M' = Bool
True
_validFlagEmoji Char
'T' Char
'N' = Bool
True
_validFlagEmoji Char
'T' Char
'O' = Bool
True
_validFlagEmoji Char
'T' Char
'R' = Bool
True
_validFlagEmoji Char
'T' Char
'T' = Bool
True
_validFlagEmoji Char
'T' Char
'V' = Bool
True
_validFlagEmoji Char
'T' Char
'W' = Bool
True
_validFlagEmoji Char
'T' Char
'Z' = Bool
True
_validFlagEmoji Char
'U' Char
'A' = Bool
True
_validFlagEmoji Char
'U' Char
'G' = Bool
True
_validFlagEmoji Char
'U' Char
'M' = Bool
True
_validFlagEmoji Char
'U' Char
'N' = Bool
True
_validFlagEmoji Char
'U' Char
'S' = Bool
True
_validFlagEmoji Char
'U' Char
'Y' = Bool
True
_validFlagEmoji Char
'U' Char
'Z' = Bool
True
_validFlagEmoji Char
'V' Char
'A' = Bool
True
_validFlagEmoji Char
'V' Char
'C' = Bool
True
_validFlagEmoji Char
'V' Char
'E' = Bool
True
_validFlagEmoji Char
'V' Char
'G' = Bool
True
_validFlagEmoji Char
'V' Char
'I' = Bool
True
_validFlagEmoji Char
'V' Char
'N' = Bool
True
_validFlagEmoji Char
'V' Char
'U' = Bool
True
_validFlagEmoji Char
'W' Char
'F' = Bool
True
_validFlagEmoji Char
'W' Char
'S' = Bool
True
_validFlagEmoji Char
'X' Char
'K' = Bool
True
_validFlagEmoji Char
'Y' Char
'E' = Bool
True
_validFlagEmoji Char
'Y' Char
'T' = Bool
True
_validFlagEmoji Char
'Z' Char
'A' = Bool
True
_validFlagEmoji Char
'Z' Char
'M' = Bool
True
_validFlagEmoji Char
'Z' Char
'W' = Bool
True
_validFlagEmoji Char
_ Char
_ = Bool
False

instance Arbitrary SkinColorModifier where
    arbitrary :: Gen SkinColorModifier
arbitrary = Gen SkinColorModifier
forall a. (Bounded a, Enum a) => Gen a
arbitraryBoundedEnum

instance Arbitrary Gender where
    arbitrary :: Gen Gender
arbitrary = Gen Gender
forall a. (Bounded a, Enum a) => Gen a
arbitraryBoundedEnum

instance Arbitrary Zodiac where
    arbitrary :: Gen Zodiac
arbitrary = Gen Zodiac
forall a. (Bounded a, Enum a) => Gen a
arbitraryBoundedEnum

instance Arbitrary Clock where
    arbitrary :: Gen Clock
arbitrary = Gen Clock
forall a. (Bounded a, Enum a) => Gen a
arbitraryBoundedEnum

instance Arbitrary MoonPhase where
    arbitrary :: Gen MoonPhase
arbitrary = Gen MoonPhase
forall a. (Bounded a, Enum a) => Gen a
arbitraryBoundedEnum

instance Arbitrary Flag where
    arbitrary :: Gen Flag
arbitrary = Gen Flag
forall a. (Bounded a, Enum a) => Gen a
arbitraryBoundedEnum

instance Arbitrary SubFlag where
    arbitrary :: Gen SubFlag
arbitrary = Gen SubFlag
forall a. (Bounded a, Enum a) => Gen a
arbitraryBoundedEnum

instance Arbitrary BloodType where
    arbitrary :: Gen BloodType
arbitrary = Gen BloodType
forall a. (Bounded a, Enum a) => Gen a
arbitraryBoundedEnum

instance Enum Flag where
    fromEnum :: Flag -> Int
fromEnum Flag
AC = Int
0
    fromEnum Flag
AD = Int
1
    fromEnum Flag
AE = Int
2
    fromEnum Flag
AF = Int
3
    fromEnum Flag
AG = Int
4
    fromEnum Flag
AI = Int
5
    fromEnum Flag
AL = Int
6
    fromEnum Flag
AM = Int
7
    fromEnum Flag
AO = Int
8
    fromEnum Flag
AQ = Int
9
    fromEnum Flag
AR = Int
10
    fromEnum Flag
AS = Int
11
    fromEnum Flag
AT = Int
12
    fromEnum Flag
AU = Int
13
    fromEnum Flag
AW = Int
14
    fromEnum Flag
AX = Int
15
    fromEnum Flag
AZ = Int
16
    fromEnum Flag
BA = Int
17
    fromEnum Flag
BB = Int
18
    fromEnum Flag
BD = Int
19
    fromEnum Flag
BE = Int
20
    fromEnum Flag
BF = Int
21
    fromEnum Flag
BG = Int
22
    fromEnum Flag
BH = Int
23
    fromEnum Flag
BI = Int
24
    fromEnum Flag
BJ = Int
25
    fromEnum Flag
BL = Int
26
    fromEnum Flag
BM = Int
27
    fromEnum Flag
BN = Int
28
    fromEnum Flag
BO = Int
29
    fromEnum Flag
BQ = Int
30
    fromEnum Flag
BR = Int
31
    fromEnum Flag
BS = Int
32
    fromEnum Flag
BT = Int
33
    fromEnum Flag
BV = Int
34
    fromEnum Flag
BW = Int
35
    fromEnum Flag
BY = Int
36
    fromEnum Flag
BZ = Int
37
    fromEnum Flag
CA = Int
38
    fromEnum Flag
CC = Int
39
    fromEnum Flag
CD = Int
40
    fromEnum Flag
CF = Int
41
    fromEnum Flag
CG = Int
42
    fromEnum Flag
CH = Int
43
    fromEnum Flag
CI = Int
44
    fromEnum Flag
CK = Int
45
    fromEnum Flag
CL = Int
46
    fromEnum Flag
CM = Int
47
    fromEnum Flag
CN = Int
48
    fromEnum Flag
CO = Int
49
    fromEnum Flag
CP = Int
50
    fromEnum Flag
CR = Int
51
    fromEnum Flag
CU = Int
52
    fromEnum Flag
CV = Int
53
    fromEnum Flag
CW = Int
54
    fromEnum Flag
CX = Int
55
    fromEnum Flag
CY = Int
56
    fromEnum Flag
CZ = Int
57
    fromEnum Flag
DE = Int
58
    fromEnum Flag
DG = Int
59
    fromEnum Flag
DJ = Int
60
    fromEnum Flag
DK = Int
61
    fromEnum Flag
DM = Int
62
    fromEnum Flag
DO = Int
63
    fromEnum Flag
DZ = Int
64
    fromEnum Flag
EA = Int
65
    fromEnum Flag
EC = Int
66
    fromEnum Flag
EE = Int
67
    fromEnum Flag
EG = Int
68
    fromEnum Flag
EH = Int
69
    fromEnum Flag
ER = Int
70
    fromEnum Flag
ES = Int
71
    fromEnum Flag
ET = Int
72
    fromEnum Flag
EU = Int
73
    fromEnum Flag
FI = Int
74
    fromEnum Flag
FJ = Int
75
    fromEnum Flag
FK = Int
76
    fromEnum Flag
FM = Int
77
    fromEnum Flag
FO = Int
78
    fromEnum Flag
FR = Int
79
    fromEnum Flag
GA = Int
80
    fromEnum Flag
GB = Int
81
    fromEnum Flag
GD = Int
82
    fromEnum Flag
GE = Int
83
    fromEnum Flag
GF = Int
84
    fromEnum Flag
GG = Int
85
    fromEnum Flag
GH = Int
86
    fromEnum Flag
GI = Int
87
    fromEnum Flag
GL = Int
88
    fromEnum Flag
GM = Int
89
    fromEnum Flag
GN = Int
90
    fromEnum Flag
GP = Int
91
    fromEnum Flag
GQ = Int
92
    fromEnum Flag
GR = Int
93
    fromEnum Flag
GS = Int
94
    fromEnum Flag
GT = Int
95
    fromEnum Flag
GU = Int
96
    fromEnum Flag
GW = Int
97
    fromEnum Flag
GY = Int
98
    fromEnum Flag
HK = Int
99
    fromEnum Flag
HM = Int
100
    fromEnum Flag
HN = Int
101
    fromEnum Flag
HR = Int
102
    fromEnum Flag
HT = Int
103
    fromEnum Flag
HU = Int
104
    fromEnum Flag
IC = Int
105
    fromEnum Flag
ID = Int
106
    fromEnum Flag
IE = Int
107
    fromEnum Flag
IL = Int
108
    fromEnum Flag
IM = Int
109
    fromEnum Flag
IN = Int
110
    fromEnum Flag
IO = Int
111
    fromEnum Flag
IQ = Int
112
    fromEnum Flag
IR = Int
113
    fromEnum Flag
IS = Int
114
    fromEnum Flag
IT = Int
115
    fromEnum Flag
JE = Int
116
    fromEnum Flag
JM = Int
117
    fromEnum Flag
JO = Int
118
    fromEnum Flag
JP = Int
119
    fromEnum Flag
KE = Int
120
    fromEnum Flag
KG = Int
121
    fromEnum Flag
KH = Int
122
    fromEnum Flag
KI = Int
123
    fromEnum Flag
KM = Int
124
    fromEnum Flag
KN = Int
125
    fromEnum Flag
KP = Int
126
    fromEnum Flag
KR = Int
127
    fromEnum Flag
KW = Int
128
    fromEnum Flag
KY = Int
129
    fromEnum Flag
KZ = Int
130
    fromEnum Flag
LA = Int
131
    fromEnum Flag
LB = Int
132
    fromEnum Flag
LC = Int
133
    fromEnum Flag
LI = Int
134
    fromEnum Flag
LK = Int
135
    fromEnum Flag
LR = Int
136
    fromEnum Flag
LS = Int
137
    fromEnum Flag
LT = Int
138
    fromEnum Flag
LU = Int
139
    fromEnum Flag
LV = Int
140
    fromEnum Flag
LY = Int
141
    fromEnum Flag
MA = Int
142
    fromEnum Flag
MC = Int
143
    fromEnum Flag
MD = Int
144
    fromEnum Flag
ME = Int
145
    fromEnum Flag
MF = Int
146
    fromEnum Flag
MG = Int
147
    fromEnum Flag
MH = Int
148
    fromEnum Flag
MK = Int
149
    fromEnum Flag
ML = Int
150
    fromEnum Flag
MM = Int
151
    fromEnum Flag
MN = Int
152
    fromEnum Flag
MO = Int
153
    fromEnum Flag
MP = Int
154
    fromEnum Flag
MQ = Int
155
    fromEnum Flag
MR = Int
156
    fromEnum Flag
MS = Int
157
    fromEnum Flag
MT = Int
158
    fromEnum Flag
MU = Int
159
    fromEnum Flag
MV = Int
160
    fromEnum Flag
MW = Int
161
    fromEnum Flag
MX = Int
162
    fromEnum Flag
MY = Int
163
    fromEnum Flag
MZ = Int
164
    fromEnum Flag
NA = Int
165
    fromEnum Flag
NC = Int
166
    fromEnum Flag
NE = Int
167
    fromEnum Flag
NF = Int
168
    fromEnum Flag
NG = Int
169
    fromEnum Flag
NI = Int
170
    fromEnum Flag
NL = Int
171
    fromEnum Flag
NO = Int
172
    fromEnum Flag
NP = Int
173
    fromEnum Flag
NR = Int
174
    fromEnum Flag
NU = Int
175
    fromEnum Flag
NZ = Int
176
    fromEnum Flag
OM = Int
177
    fromEnum Flag
PA = Int
178
    fromEnum Flag
PE = Int
179
    fromEnum Flag
PF = Int
180
    fromEnum Flag
PG = Int
181
    fromEnum Flag
PH = Int
182
    fromEnum Flag
PK = Int
183
    fromEnum Flag
PL = Int
184
    fromEnum Flag
PM = Int
185
    fromEnum Flag
PN = Int
186
    fromEnum Flag
PR = Int
187
    fromEnum Flag
PS = Int
188
    fromEnum Flag
PT = Int
189
    fromEnum Flag
PW = Int
190
    fromEnum Flag
PY = Int
191
    fromEnum Flag
QA = Int
192
    fromEnum Flag
RE = Int
193
    fromEnum Flag
RO = Int
194
    fromEnum Flag
RS = Int
195
    fromEnum Flag
RU = Int
196
    fromEnum Flag
RW = Int
197
    fromEnum Flag
SA = Int
198
    fromEnum Flag
SB = Int
199
    fromEnum Flag
SC = Int
200
    fromEnum Flag
SD = Int
201
    fromEnum Flag
SE = Int
202
    fromEnum Flag
SG = Int
203
    fromEnum Flag
SH = Int
204
    fromEnum Flag
SI = Int
205
    fromEnum Flag
SJ = Int
206
    fromEnum Flag
SK = Int
207
    fromEnum Flag
SL = Int
208
    fromEnum Flag
SM = Int
209
    fromEnum Flag
SN = Int
210
    fromEnum Flag
SO = Int
211
    fromEnum Flag
SR = Int
212
    fromEnum Flag
SS = Int
213
    fromEnum Flag
ST = Int
214
    fromEnum Flag
SV = Int
215
    fromEnum Flag
SX = Int
216
    fromEnum Flag
SY = Int
217
    fromEnum Flag
SZ = Int
218
    fromEnum Flag
TA = Int
219
    fromEnum Flag
TC = Int
220
    fromEnum Flag
TD = Int
221
    fromEnum Flag
TF = Int
222
    fromEnum Flag
TG = Int
223
    fromEnum Flag
TH = Int
224
    fromEnum Flag
TJ = Int
225
    fromEnum Flag
TK = Int
226
    fromEnum Flag
TL = Int
227
    fromEnum Flag
TM = Int
228
    fromEnum Flag
TN = Int
229
    fromEnum Flag
TO = Int
230
    fromEnum Flag
TR = Int
231
    fromEnum Flag
TT = Int
232
    fromEnum Flag
TV = Int
233
    fromEnum Flag
TW = Int
234
    fromEnum Flag
TZ = Int
235
    fromEnum Flag
UA = Int
236
    fromEnum Flag
UG = Int
237
    fromEnum Flag
UM = Int
238
    fromEnum Flag
UN = Int
239
    fromEnum Flag
US = Int
240
    fromEnum Flag
UY = Int
241
    fromEnum Flag
UZ = Int
242
    fromEnum Flag
VA = Int
243
    fromEnum Flag
VC = Int
244
    fromEnum Flag
VE = Int
245
    fromEnum Flag
VG = Int
246
    fromEnum Flag
VI = Int
247
    fromEnum Flag
VN = Int
248
    fromEnum Flag
VU = Int
249
    fromEnum Flag
WF = Int
250
    fromEnum Flag
WS = Int
251
    fromEnum Flag
XK = Int
252
    fromEnum Flag
YE = Int
253
    fromEnum Flag
YT = Int
254
    fromEnum Flag
ZA = Int
255
    fromEnum Flag
ZM = Int
256
    fromEnum Flag
ZW = Int
257
    fromEnum Flag
f = String -> Flag -> Int
forall a b. Show a => String -> a -> b
fromEnumError String
"Flag" Flag
f
    toEnum :: Int -> Flag
toEnum Int
0 = Flag
AC
    toEnum Int
1 = Flag
AD
    toEnum Int
2 = Flag
AE
    toEnum Int
3 = Flag
AF
    toEnum Int
4 = Flag
AG
    toEnum Int
5 = Flag
AI
    toEnum Int
6 = Flag
AL
    toEnum Int
7 = Flag
AM
    toEnum Int
8 = Flag
AO
    toEnum Int
9 = Flag
AQ
    toEnum Int
10 = Flag
AR
    toEnum Int
11 = Flag
AS
    toEnum Int
12 = Flag
AT
    toEnum Int
13 = Flag
AU
    toEnum Int
14 = Flag
AW
    toEnum Int
15 = Flag
AX
    toEnum Int
16 = Flag
AZ
    toEnum Int
17 = Flag
BA
    toEnum Int
18 = Flag
BB
    toEnum Int
19 = Flag
BD
    toEnum Int
20 = Flag
BE
    toEnum Int
21 = Flag
BF
    toEnum Int
22 = Flag
BG
    toEnum Int
23 = Flag
BH
    toEnum Int
24 = Flag
BI
    toEnum Int
25 = Flag
BJ
    toEnum Int
26 = Flag
BL
    toEnum Int
27 = Flag
BM
    toEnum Int
28 = Flag
BN
    toEnum Int
29 = Flag
BO
    toEnum Int
30 = Flag
BQ
    toEnum Int
31 = Flag
BR
    toEnum Int
32 = Flag
BS
    toEnum Int
33 = Flag
BT
    toEnum Int
34 = Flag
BV
    toEnum Int
35 = Flag
BW
    toEnum Int
36 = Flag
BY
    toEnum Int
37 = Flag
BZ
    toEnum Int
38 = Flag
CA
    toEnum Int
39 = Flag
CC
    toEnum Int
40 = Flag
CD
    toEnum Int
41 = Flag
CF
    toEnum Int
42 = Flag
CG
    toEnum Int
43 = Flag
CH
    toEnum Int
44 = Flag
CI
    toEnum Int
45 = Flag
CK
    toEnum Int
46 = Flag
CL
    toEnum Int
47 = Flag
CM
    toEnum Int
48 = Flag
CN
    toEnum Int
49 = Flag
CO
    toEnum Int
50 = Flag
CP
    toEnum Int
51 = Flag
CR
    toEnum Int
52 = Flag
CU
    toEnum Int
53 = Flag
CV
    toEnum Int
54 = Flag
CW
    toEnum Int
55 = Flag
CX
    toEnum Int
56 = Flag
CY
    toEnum Int
57 = Flag
CZ
    toEnum Int
58 = Flag
DE
    toEnum Int
59 = Flag
DG
    toEnum Int
60 = Flag
DJ
    toEnum Int
61 = Flag
DK
    toEnum Int
62 = Flag
DM
    toEnum Int
63 = Flag
DO
    toEnum Int
64 = Flag
DZ
    toEnum Int
65 = Flag
EA
    toEnum Int
66 = Flag
EC
    toEnum Int
67 = Flag
EE
    toEnum Int
68 = Flag
EG
    toEnum Int
69 = Flag
EH
    toEnum Int
70 = Flag
ER
    toEnum Int
71 = Flag
ES
    toEnum Int
72 = Flag
ET
    toEnum Int
73 = Flag
EU
    toEnum Int
74 = Flag
FI
    toEnum Int
75 = Flag
FJ
    toEnum Int
76 = Flag
FK
    toEnum Int
77 = Flag
FM
    toEnum Int
78 = Flag
FO
    toEnum Int
79 = Flag
FR
    toEnum Int
80 = Flag
GA
    toEnum Int
81 = Flag
GB
    toEnum Int
82 = Flag
GD
    toEnum Int
83 = Flag
GE
    toEnum Int
84 = Flag
GF
    toEnum Int
85 = Flag
GG
    toEnum Int
86 = Flag
GH
    toEnum Int
87 = Flag
GI
    toEnum Int
88 = Flag
GL
    toEnum Int
89 = Flag
GM
    toEnum Int
90 = Flag
GN
    toEnum Int
91 = Flag
GP
    toEnum Int
92 = Flag
GQ
    toEnum Int
93 = Flag
GR
    toEnum Int
94 = Flag
GS
    toEnum Int
95 = Flag
GT
    toEnum Int
96 = Flag
GU
    toEnum Int
97 = Flag
GW
    toEnum Int
98 = Flag
GY
    toEnum Int
99 = Flag
HK
    toEnum Int
100 = Flag
HM
    toEnum Int
101 = Flag
HN
    toEnum Int
102 = Flag
HR
    toEnum Int
103 = Flag
HT
    toEnum Int
104 = Flag
HU
    toEnum Int
105 = Flag
IC
    toEnum Int
106 = Flag
ID
    toEnum Int
107 = Flag
IE
    toEnum Int
108 = Flag
IL
    toEnum Int
109 = Flag
IM
    toEnum Int
110 = Flag
IN
    toEnum Int
111 = Flag
IO
    toEnum Int
112 = Flag
IQ
    toEnum Int
113 = Flag
IR
    toEnum Int
114 = Flag
IS
    toEnum Int
115 = Flag
IT
    toEnum Int
116 = Flag
JE
    toEnum Int
117 = Flag
JM
    toEnum Int
118 = Flag
JO
    toEnum Int
119 = Flag
JP
    toEnum Int
120 = Flag
KE
    toEnum Int
121 = Flag
KG
    toEnum Int
122 = Flag
KH
    toEnum Int
123 = Flag
KI
    toEnum Int
124 = Flag
KM
    toEnum Int
125 = Flag
KN
    toEnum Int
126 = Flag
KP
    toEnum Int
127 = Flag
KR
    toEnum Int
128 = Flag
KW
    toEnum Int
129 = Flag
KY
    toEnum Int
130 = Flag
KZ
    toEnum Int
131 = Flag
LA
    toEnum Int
132 = Flag
LB
    toEnum Int
133 = Flag
LC
    toEnum Int
134 = Flag
LI
    toEnum Int
135 = Flag
LK
    toEnum Int
136 = Flag
LR
    toEnum Int
137 = Flag
LS
    toEnum Int
138 = Flag
LT
    toEnum Int
139 = Flag
LU
    toEnum Int
140 = Flag
LV
    toEnum Int
141 = Flag
LY
    toEnum Int
142 = Flag
MA
    toEnum Int
143 = Flag
MC
    toEnum Int
144 = Flag
MD
    toEnum Int
145 = Flag
ME
    toEnum Int
146 = Flag
MF
    toEnum Int
147 = Flag
MG
    toEnum Int
148 = Flag
MH
    toEnum Int
149 = Flag
MK
    toEnum Int
150 = Flag
ML
    toEnum Int
151 = Flag
MM
    toEnum Int
152 = Flag
MN
    toEnum Int
153 = Flag
MO
    toEnum Int
154 = Flag
MP
    toEnum Int
155 = Flag
MQ
    toEnum Int
156 = Flag
MR
    toEnum Int
157 = Flag
MS
    toEnum Int
158 = Flag
MT
    toEnum Int
159 = Flag
MU
    toEnum Int
160 = Flag
MV
    toEnum Int
161 = Flag
MW
    toEnum Int
162 = Flag
MX
    toEnum Int
163 = Flag
MY
    toEnum Int
164 = Flag
MZ
    toEnum Int
165 = Flag
NA
    toEnum Int
166 = Flag
NC
    toEnum Int
167 = Flag
NE
    toEnum Int
168 = Flag
NF
    toEnum Int
169 = Flag
NG
    toEnum Int
170 = Flag
NI
    toEnum Int
171 = Flag
NL
    toEnum Int
172 = Flag
NO
    toEnum Int
173 = Flag
NP
    toEnum Int
174 = Flag
NR
    toEnum Int
175 = Flag
NU
    toEnum Int
176 = Flag
NZ
    toEnum Int
177 = Flag
OM
    toEnum Int
178 = Flag
PA
    toEnum Int
179 = Flag
PE
    toEnum Int
180 = Flag
PF
    toEnum Int
181 = Flag
PG
    toEnum Int
182 = Flag
PH
    toEnum Int
183 = Flag
PK
    toEnum Int
184 = Flag
PL
    toEnum Int
185 = Flag
PM
    toEnum Int
186 = Flag
PN
    toEnum Int
187 = Flag
PR
    toEnum Int
188 = Flag
PS
    toEnum Int
189 = Flag
PT
    toEnum Int
190 = Flag
PW
    toEnum Int
191 = Flag
PY
    toEnum Int
192 = Flag
QA
    toEnum Int
193 = Flag
RE
    toEnum Int
194 = Flag
RO
    toEnum Int
195 = Flag
RS
    toEnum Int
196 = Flag
RU
    toEnum Int
197 = Flag
RW
    toEnum Int
198 = Flag
SA
    toEnum Int
199 = Flag
SB
    toEnum Int
200 = Flag
SC
    toEnum Int
201 = Flag
SD
    toEnum Int
202 = Flag
SE
    toEnum Int
203 = Flag
SG
    toEnum Int
204 = Flag
SH
    toEnum Int
205 = Flag
SI
    toEnum Int
206 = Flag
SJ
    toEnum Int
207 = Flag
SK
    toEnum Int
208 = Flag
SL
    toEnum Int
209 = Flag
SM
    toEnum Int
210 = Flag
SN
    toEnum Int
211 = Flag
SO
    toEnum Int
212 = Flag
SR
    toEnum Int
213 = Flag
SS
    toEnum Int
214 = Flag
ST
    toEnum Int
215 = Flag
SV
    toEnum Int
216 = Flag
SX
    toEnum Int
217 = Flag
SY
    toEnum Int
218 = Flag
SZ
    toEnum Int
219 = Flag
TA
    toEnum Int
220 = Flag
TC
    toEnum Int
221 = Flag
TD
    toEnum Int
222 = Flag
TF
    toEnum Int
223 = Flag
TG
    toEnum Int
224 = Flag
TH
    toEnum Int
225 = Flag
TJ
    toEnum Int
226 = Flag
TK
    toEnum Int
227 = Flag
TL
    toEnum Int
228 = Flag
TM
    toEnum Int
229 = Flag
TN
    toEnum Int
230 = Flag
TO
    toEnum Int
231 = Flag
TR
    toEnum Int
232 = Flag
TT
    toEnum Int
233 = Flag
TV
    toEnum Int
234 = Flag
TW
    toEnum Int
235 = Flag
TZ
    toEnum Int
236 = Flag
UA
    toEnum Int
237 = Flag
UG
    toEnum Int
238 = Flag
UM
    toEnum Int
239 = Flag
UN
    toEnum Int
240 = Flag
US
    toEnum Int
241 = Flag
UY
    toEnum Int
242 = Flag
UZ
    toEnum Int
243 = Flag
VA
    toEnum Int
244 = Flag
VC
    toEnum Int
245 = Flag
VE
    toEnum Int
246 = Flag
VG
    toEnum Int
247 = Flag
VI
    toEnum Int
248 = Flag
VN
    toEnum Int
249 = Flag
VU
    toEnum Int
250 = Flag
WF
    toEnum Int
251 = Flag
WS
    toEnum Int
252 = Flag
XK
    toEnum Int
253 = Flag
YE
    toEnum Int
254 = Flag
YT
    toEnum Int
255 = Flag
ZA
    toEnum Int
256 = Flag
ZM
    toEnum Int
257 = Flag
ZW
    toEnum Int
i = String -> Int -> (Flag, Flag) -> Flag
forall a b. Show a => String -> Int -> (a, a) -> b
toEnumError String
"Flag" Int
i (Flag
forall a. Bounded a => a
minBound :: Flag, Flag
forall a. Bounded a => a
maxBound)
    enumFrom :: Flag -> [Flag]
enumFrom = (Flag -> Flag -> [Flag]
forall a. Enum a => a -> a -> [a]
`enumFromTo` Flag
forall a. Bounded a => a
maxBound)
    enumFromThen :: Flag -> Flag -> [Flag]
enumFromThen Flag
x Flag
y = Flag -> Flag -> Flag -> [Flag]
forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo Flag
x Flag
y Flag
forall a. Bounded a => a
maxBound

instance Enum SubFlag where
    fromEnum :: SubFlag -> Int
fromEnum SubFlag
ENG = Int
0
    fromEnum SubFlag
SCT = Int
1
    fromEnum SubFlag
WLS = Int
2
    fromEnum SubFlag
s = String -> SubFlag -> Int
forall a b. Show a => String -> a -> b
fromEnumError String
"SubFlag" SubFlag
s
    toEnum :: Int -> SubFlag
toEnum Int
0 = SubFlag
ENG
    toEnum Int
1 = SubFlag
SCT
    toEnum Int
2 = SubFlag
WLS
    toEnum Int
i = String -> Int -> (SubFlag, SubFlag) -> SubFlag
forall a b. Show a => String -> Int -> (a, a) -> b
toEnumError String
"SubFlag" Int
i (SubFlag
forall a. Bounded a => a
minBound :: SubFlag, SubFlag
forall a. Bounded a => a
maxBound)
    enumFrom :: SubFlag -> [SubFlag]
enumFrom = (SubFlag -> SubFlag -> [SubFlag]
forall a. Enum a => a -> a -> [a]
`enumFromTo` SubFlag
forall a. Bounded a => a
maxBound)
    enumFromThen :: SubFlag -> SubFlag -> [SubFlag]
enumFromThen SubFlag
x SubFlag
y = SubFlag -> SubFlag -> SubFlag -> [SubFlag]
forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo SubFlag
x SubFlag
y SubFlag
forall a. Bounded a => a
maxBound

instance UnicodeCharacter SkinColorModifier where
    toUnicodeChar :: SkinColorModifier -> Char
toUnicodeChar = Int -> SkinColorModifier -> Char
forall a. Enum a => Int -> a -> Char
mapFromEnum Int
_skinColorOffset
    fromUnicodeChar :: Char -> Maybe SkinColorModifier
fromUnicodeChar = Int -> Char -> Maybe SkinColorModifier
forall a. (Bounded a, Enum a) => Int -> Char -> Maybe a
mapToEnumSafe Int
_skinColorOffset
    fromUnicodeChar' :: Char -> SkinColorModifier
fromUnicodeChar' = Int -> Char -> SkinColorModifier
forall a. Enum a => Int -> Char -> a
mapToEnum Int
_skinColorOffset

instance UnicodeCharacter Zodiac where
    toUnicodeChar :: Zodiac -> Char
toUnicodeChar = Int -> Zodiac -> Char
forall a. Enum a => Int -> a -> Char
mapFromEnum Int
_zodiacOffset
    fromUnicodeChar :: Char -> Maybe Zodiac
fromUnicodeChar = Int -> Char -> Maybe Zodiac
forall a. (Bounded a, Enum a) => Int -> Char -> Maybe a
mapToEnumSafe Int
_zodiacOffset
    fromUnicodeChar' :: Char -> Zodiac
fromUnicodeChar' = Int -> Char -> Zodiac
forall a. Enum a => Int -> Char -> a
mapToEnum Int
_zodiacOffset

instance UnicodeCharacter MoonPhase where
    toUnicodeChar :: MoonPhase -> Char
toUnicodeChar = Int -> MoonPhase -> Char
forall a. Enum a => Int -> a -> Char
mapFromEnum Int
_moonPhaseOffset
    fromUnicodeChar :: Char -> Maybe MoonPhase
fromUnicodeChar = Int -> Char -> Maybe MoonPhase
forall a. (Bounded a, Enum a) => Int -> Char -> Maybe a
mapToEnumSafe Int
_moonPhaseOffset
    fromUnicodeChar' :: Char -> MoonPhase
fromUnicodeChar' = Int -> Char -> MoonPhase
forall a. Enum a => Int -> Char -> a
mapToEnum Int
_moonPhaseOffset

instance UnicodeCharacter Clock where
    toUnicodeChar :: Clock -> Char
toUnicodeChar (Clock Int
h Bool
False) = Int -> Char
chr (Int
0x1f54f Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
h)
    toUnicodeChar (Clock Int
h Bool
True) = Int -> Char
chr (Int
0x1f55c Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int -> Int -> Int
forall a. Integral a => a -> a -> a
mod (Int
hInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1) Int
12)
    fromUnicodeChar :: Char -> Maybe Clock
fromUnicodeChar Char
c
        | Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
< Char
'\x1f550' = Maybe Clock
forall a. Maybe a
Nothing
        | Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
< Char
'\x1f55c' = Clock -> Maybe Clock
forall a. a -> Maybe a
Just (Int -> Bool -> Clock
Clock (Char -> Int
ord Char
c Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
0x1f54f) Bool
False)
        | Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
< Char
'\x1f568' = Clock -> Maybe Clock
forall a. a -> Maybe a
Just (Int -> Bool -> Clock
Clock (Int -> Int -> Int
forall a. Integral a => a -> a -> a
mod (Char -> Int
ord Char
c Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
0x1f55b) Int
12) Bool
True)
        | Bool
otherwise = Maybe Clock
forall a. Maybe a
Nothing

instance UnicodeText Flag where
    toUnicodeText :: Flag -> Text
toUnicodeText (Flag Char
ca Char
cb) = Char -> Char -> Text
iso3166Alpha2ToFlag' Char
ca Char
cb
    fromUnicodeText :: Text -> Maybe Flag
fromUnicodeText = Text -> Maybe Flag
fromFlag

instance UnicodeText SubFlag where
    toUnicodeText :: SubFlag -> Text
toUnicodeText (SubFlag (Flag Char
ca Char
cb) Char
cc Char
cd Char
ce) = String -> Text
pack (Char
'\x1f3f4' Char -> ShowS
forall a. a -> [a] -> [a]
: Char -> Char
go' Char
ca Char -> ShowS
forall a. a -> [a] -> [a]
: Char -> Char
go' Char
cb Char -> ShowS
forall a. a -> [a] -> [a]
: (Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
go [Char
cc, Char
cd, Char
ce, Char
'\DEL'])
        where go :: Char -> Char
go = Int -> Char
chr (Int -> Char) -> (Char -> Int) -> Char -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int
0xe0000 Int -> Int -> Int
forall a. Bits a => a -> a -> a
.|.) (Int -> Int) -> (Char -> Int) -> Char -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
ord
              go' :: Char -> Char
go' = Char -> Char
go (Char -> Char) -> (Char -> Char) -> Char -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char
toLower
    fromUnicodeText :: Text -> Maybe SubFlag
fromUnicodeText Text
t
        | [Char
'\x1f3f4', Char
'\xe0067', Char
'\xe0062', Char
sa, Char
sb, Char
sc, Char
'\xe007f'] <- Text -> String
unpack Text
t = Char -> Char -> Char -> Maybe SubFlag
go Char
sa Char
sb Char
sc
        | Bool
otherwise = Maybe SubFlag
forall a. Maybe a
Nothing
        where go :: Char -> Char -> Char -> Maybe SubFlag
go Char
'\xe0065' Char
'\xe006e' Char
'\xe0067' = SubFlag -> Maybe SubFlag
forall a. a -> Maybe a
Just SubFlag
ENG
              go Char
'\xe0073' Char
'\xe0063' Char
'\xe0074' = SubFlag -> Maybe SubFlag
forall a. a -> Maybe a
Just SubFlag
SCT
              go Char
'\xe0077' Char
'\xe006c' Char
'\xe0073' = SubFlag -> Maybe SubFlag
forall a. a -> Maybe a
Just SubFlag
WLS
              go Char
_ Char
_ Char
_ = Maybe SubFlag
forall a. Maybe a
Nothing

instance UnicodeText SkinColorModifier
instance UnicodeText Zodiac
instance UnicodeText MoonPhase
instance UnicodeText Clock

instance UnicodeText Gender where
    toUnicodeText :: Gender -> Text
toUnicodeText Gender
Male = Text
"\x2640\xfe0f"
    toUnicodeText Gender
Female = Text
"\x2642\xfe0f"
    fromUnicodeText :: Text -> Maybe Gender
fromUnicodeText Text
"\x2640\xfe0f" = Gender -> Maybe Gender
forall a. a -> Maybe a
Just Gender
Male
    fromUnicodeText Text
"\x2642\xfe0f" = Gender -> Maybe Gender
forall a. a -> Maybe a
Just Gender
Female
    fromUnicodeText Text
_ = Maybe Gender
forall a. Maybe a
Nothing

instance UnicodeText BloodType where
    toUnicodeText :: BloodType -> Text
toUnicodeText BloodType
AB = Text
"\x1f18e"
    toUnicodeText BloodType
A = Text
"\x1f170\xfe0f"
    toUnicodeText BloodType
B = Text
"\x1f171\xfe0f"
    toUnicodeText BloodType
O = Text
"\x1f17e\xfe0f"
    fromUnicodeText :: Text -> Maybe BloodType
fromUnicodeText Text
"\x1f18e" = BloodType -> Maybe BloodType
forall a. a -> Maybe a
Just BloodType
AB
    fromUnicodeText Text
t
        | [Char
c, Char
EmojiSuffix] <- Text -> String
unpack Text
t = Char -> Maybe BloodType
go Char
c
        | Bool
otherwise = Maybe BloodType
forall a. Maybe a
Nothing
        where go :: Char -> Maybe BloodType
go Char
'\x1f170' = BloodType -> Maybe BloodType
forall a. a -> Maybe a
Just BloodType
A
              go Char
'\x1f171' = BloodType -> Maybe BloodType
forall a. a -> Maybe a
Just BloodType
B
              go Char
'\x1f17e' = BloodType -> Maybe BloodType
forall a. a -> Maybe a
Just BloodType
O
              go Char
_ = Maybe BloodType
forall a. Maybe a
Nothing