{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE Safe #-}
module Data.Char.Emoji.Flag
(
Flag,
flag,
flag',
flagChars,
iso3166Alpha2ToFlag,
iso3166Alpha2ToFlag',
validFlagEmoji,
SubFlag,
ExtraFlag (ChequeredFlag, TriangularFlagOnPost, CrossedFlags, BlackFlag, WavingWhiteFlag, RainbowFlag, TransgenderFlag, PirateFlag),
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 ENG,
pattern SCT,
pattern WLS,
pattern USAL,
pattern USAK,
pattern USAS,
pattern USAZ,
pattern USAR,
pattern USCA,
pattern USCO,
pattern USCT,
pattern USDE,
pattern USFL,
pattern USGA,
pattern USGU,
pattern USHI,
pattern USID,
pattern USIL,
pattern USIN,
pattern USIA,
pattern USKS,
pattern USKY,
pattern USLA,
pattern USME,
pattern USMD,
pattern USMA,
pattern USMI,
pattern USMN,
pattern USMS,
pattern USMO,
pattern USMT,
pattern USNE,
pattern USNV,
pattern USNH,
pattern USNJ,
pattern USNM,
pattern USNY,
pattern USNC,
pattern USND,
pattern USMP,
pattern USOH,
pattern USOK,
pattern USOR,
pattern USPA,
pattern USPR,
pattern USRI,
pattern USSC,
pattern USSD,
pattern USTN,
pattern USUM,
pattern USVI,
pattern USUT,
pattern USVT,
pattern USVA,
pattern USWA,
pattern USDC,
pattern USWV,
pattern USWI,
pattern USWY,
)
where
import Control.DeepSeq (NFData)
import Data.Bits ((.|.))
import Data.Char (chr, ord, toLower, toUpper)
import Data.Char.Core (UnicodeText (fromUnicodeText, isInTextRange, toUnicodeText), mapToEnumSafe)
import Data.Char.Enclosed (regionalIndicatorUppercase')
import Data.Data (Data)
import Data.Function (on)
import Data.Hashable (Hashable)
import Data.List (elemIndex)
import Data.Maybe (fromJust, fromMaybe, listToMaybe)
import Data.Text (Text, pack, unpack)
import GHC.Enum (fromEnumError, toEnumError)
import GHC.Generics (Generic)
import Test.QuickCheck.Arbitrary (Arbitrary (arbitrary), arbitraryBoundedEnum)
import Test.QuickCheck.Gen (elements)
import Prelude hiding (GT, LT)
_flagCharOffset :: Int
_flagCharOffset :: Int
_flagCharOffset = Int
0x1f1a5
data Flag = Flag Char Char deriving (Typeable Flag
Flag -> DataType
Flag -> Constr
(forall b. Data b => b -> b) -> Flag -> 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(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 (m :: * -> *).
MonadPlus m =>
(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 (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> Flag -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Flag -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Flag -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Flag -> [u]
gmapQr :: forall r r'.
(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 :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
Data, Flag -> Flag -> Bool
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. 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
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
Ord, ReadPrec [Flag]
ReadPrec Flag
Int -> ReadS Flag
ReadS [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
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
data SubFlag = SubFlag Flag Char Char (Maybe Char) deriving (Typeable SubFlag
SubFlag -> DataType
SubFlag -> Constr
(forall b. Data b => b -> b) -> SubFlag -> 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(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 (m :: * -> *).
MonadPlus m =>
(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 (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> SubFlag -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SubFlag -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> SubFlag -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SubFlag -> [u]
gmapQr :: forall r r'.
(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 :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
Data, SubFlag -> SubFlag -> Bool
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. 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
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
Ord, ReadPrec [SubFlag]
ReadPrec SubFlag
Int -> ReadS SubFlag
ReadS [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
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
flag ::
Char ->
Char ->
Maybe Flag
flag :: Char -> Char -> Maybe Flag
flag Char
ca Char
cb
| Char -> Char -> Bool
_validFlagEmoji Char
a Char
b = forall a. a -> Maybe a
Just (Char -> Char -> Flag
Flag Char
a Char
b)
| Bool
otherwise = forall a. Maybe a
Nothing
where
a :: Char
a = Char -> Char
toUpper Char
ca
b :: Char
b = Char -> Char
toUpper Char
cb
flag' ::
Char ->
Char ->
Flag
flag' :: Char -> Char -> Flag
flag' Char
ca = forall a. HasCallStack => Maybe a -> a
fromJust forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char -> Maybe Flag
flag Char
ca
flagChars ::
Flag ->
(Char, Char)
flagChars :: Flag -> (Char, Char)
flagChars (Flag Char
ca Char
cb) = (Char
ca, Char
cb)
pattern AC :: Flag
pattern $bAC :: Flag
$mAC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AC = Flag 'A' 'C'
pattern AD :: Flag
pattern $bAD :: Flag
$mAD :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AD = Flag 'A' 'D'
pattern AE :: Flag
pattern $bAE :: Flag
$mAE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AE = Flag 'A' 'E'
pattern AF :: Flag
pattern $bAF :: Flag
$mAF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AF = Flag 'A' 'F'
pattern AG :: Flag
pattern $bAG :: Flag
$mAG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AG = Flag 'A' 'G'
pattern AI :: Flag
pattern $bAI :: Flag
$mAI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AI = Flag 'A' 'I'
pattern AL :: Flag
pattern $bAL :: Flag
$mAL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AL = Flag 'A' 'L'
pattern AM :: Flag
pattern $bAM :: Flag
$mAM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AM = Flag 'A' 'M'
pattern AO :: Flag
pattern $bAO :: Flag
$mAO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AO = Flag 'A' 'O'
pattern AQ :: Flag
pattern $bAQ :: Flag
$mAQ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AQ = Flag 'A' 'Q'
pattern AR :: Flag
pattern $bAR :: Flag
$mAR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AR = Flag 'A' 'R'
pattern AS :: Flag
pattern $bAS :: Flag
$mAS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AS = Flag 'A' 'S'
pattern AT :: Flag
pattern $bAT :: Flag
$mAT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AT = Flag 'A' 'T'
pattern AU :: Flag
pattern $bAU :: Flag
$mAU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AU = Flag 'A' 'U'
pattern AW :: Flag
pattern $bAW :: Flag
$mAW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AW = Flag 'A' 'W'
pattern AX :: Flag
pattern $bAX :: Flag
$mAX :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AX = Flag 'A' 'X'
pattern AZ :: Flag
pattern $bAZ :: Flag
$mAZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AZ = Flag 'A' 'Z'
pattern BA :: Flag
pattern $bBA :: Flag
$mBA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BA = Flag 'B' 'A'
pattern BB :: Flag
pattern $bBB :: Flag
$mBB :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BB = Flag 'B' 'B'
pattern BD :: Flag
pattern $bBD :: Flag
$mBD :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BD = Flag 'B' 'D'
pattern BE :: Flag
pattern $bBE :: Flag
$mBE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BE = Flag 'B' 'E'
pattern BF :: Flag
pattern $bBF :: Flag
$mBF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BF = Flag 'B' 'F'
pattern BG :: Flag
pattern $bBG :: Flag
$mBG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BG = Flag 'B' 'G'
pattern BH :: Flag
pattern $bBH :: Flag
$mBH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BH = Flag 'B' 'H'
pattern BI :: Flag
pattern $bBI :: Flag
$mBI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BI = Flag 'B' 'I'
pattern BJ :: Flag
pattern $bBJ :: Flag
$mBJ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BJ = Flag 'B' 'J'
pattern BL :: Flag
pattern $bBL :: Flag
$mBL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BL = Flag 'B' 'L'
pattern BM :: Flag
pattern $bBM :: Flag
$mBM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BM = Flag 'B' 'M'
pattern BN :: Flag
pattern $bBN :: Flag
$mBN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BN = Flag 'B' 'N'
pattern BO :: Flag
pattern $bBO :: Flag
$mBO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BO = Flag 'B' 'O'
pattern BQ :: Flag
pattern $bBQ :: Flag
$mBQ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BQ = Flag 'B' 'Q'
pattern BR :: Flag
pattern $bBR :: Flag
$mBR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BR = Flag 'B' 'R'
pattern BS :: Flag
pattern $bBS :: Flag
$mBS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BS = Flag 'B' 'S'
pattern BT :: Flag
pattern $bBT :: Flag
$mBT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BT = Flag 'B' 'T'
pattern BV :: Flag
pattern $bBV :: Flag
$mBV :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BV = Flag 'B' 'V'
pattern BW :: Flag
pattern $bBW :: Flag
$mBW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BW = Flag 'B' 'W'
pattern BY :: Flag
pattern $bBY :: Flag
$mBY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BY = Flag 'B' 'Y'
pattern BZ :: Flag
pattern $bBZ :: Flag
$mBZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
BZ = Flag 'B' 'Z'
pattern CA :: Flag
pattern $bCA :: Flag
$mCA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CA = Flag 'C' 'A'
pattern CC :: Flag
pattern $bCC :: Flag
$mCC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CC = Flag 'C' 'C'
pattern CD :: Flag
pattern $bCD :: Flag
$mCD :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CD = Flag 'C' 'D'
pattern CF :: Flag
pattern $bCF :: Flag
$mCF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CF = Flag 'C' 'F'
pattern CG :: Flag
pattern $bCG :: Flag
$mCG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CG = Flag 'C' 'G'
pattern CH :: Flag
pattern $bCH :: Flag
$mCH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CH = Flag 'C' 'H'
pattern CI :: Flag
pattern $bCI :: Flag
$mCI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CI = Flag 'C' 'I'
pattern CK :: Flag
pattern $bCK :: Flag
$mCK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CK = Flag 'C' 'K'
pattern CL :: Flag
pattern $bCL :: Flag
$mCL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CL = Flag 'C' 'L'
pattern CM :: Flag
pattern $bCM :: Flag
$mCM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CM = Flag 'C' 'M'
pattern CN :: Flag
pattern $bCN :: Flag
$mCN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CN = Flag 'C' 'N'
pattern CO :: Flag
pattern $bCO :: Flag
$mCO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CO = Flag 'C' 'O'
pattern CP :: Flag
pattern $bCP :: Flag
$mCP :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CP = Flag 'C' 'P'
pattern CR :: Flag
pattern $bCR :: Flag
$mCR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CR = Flag 'C' 'R'
pattern CU :: Flag
pattern $bCU :: Flag
$mCU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CU = Flag 'C' 'U'
pattern CV :: Flag
pattern $bCV :: Flag
$mCV :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CV = Flag 'C' 'V'
pattern CW :: Flag
pattern $bCW :: Flag
$mCW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CW = Flag 'C' 'W'
pattern CX :: Flag
pattern $bCX :: Flag
$mCX :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CX = Flag 'C' 'X'
pattern CY :: Flag
pattern $bCY :: Flag
$mCY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CY = Flag 'C' 'Y'
pattern CZ :: Flag
pattern $bCZ :: Flag
$mCZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
CZ = Flag 'C' 'Z'
pattern DE :: Flag
pattern $bDE :: Flag
$mDE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
DE = Flag 'D' 'E'
pattern DG :: Flag
pattern $bDG :: Flag
$mDG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
DG = Flag 'D' 'G'
pattern DJ :: Flag
pattern $bDJ :: Flag
$mDJ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
DJ = Flag 'D' 'J'
pattern DK :: Flag
pattern $bDK :: Flag
$mDK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
DK = Flag 'D' 'K'
pattern DM :: Flag
pattern $bDM :: Flag
$mDM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
DM = Flag 'D' 'M'
pattern DO :: Flag
pattern $bDO :: Flag
$mDO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
DO = Flag 'D' 'O'
pattern DZ :: Flag
pattern $bDZ :: Flag
$mDZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
DZ = Flag 'D' 'Z'
pattern EA :: Flag
pattern $bEA :: Flag
$mEA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
EA = Flag 'E' 'A'
pattern EC :: Flag
pattern $bEC :: Flag
$mEC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
EC = Flag 'E' 'C'
pattern EE :: Flag
pattern $bEE :: Flag
$mEE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
EE = Flag 'E' 'E'
pattern EG :: Flag
pattern $bEG :: Flag
$mEG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
EG = Flag 'E' 'G'
pattern EH :: Flag
pattern $bEH :: Flag
$mEH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
EH = Flag 'E' 'H'
pattern ER :: Flag
pattern $bER :: Flag
$mER :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
ER = Flag 'E' 'R'
pattern ES :: Flag
pattern $bES :: Flag
$mES :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
ES = Flag 'E' 'S'
pattern ET :: Flag
pattern $bET :: Flag
$mET :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
ET = Flag 'E' 'T'
pattern EU :: Flag
pattern $bEU :: Flag
$mEU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
EU = Flag 'E' 'U'
pattern FI :: Flag
pattern $bFI :: Flag
$mFI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
FI = Flag 'F' 'I'
pattern FJ :: Flag
pattern $bFJ :: Flag
$mFJ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
FJ = Flag 'F' 'J'
pattern FK :: Flag
pattern $bFK :: Flag
$mFK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
FK = Flag 'F' 'K'
pattern FM :: Flag
pattern $bFM :: Flag
$mFM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
FM = Flag 'F' 'M'
pattern FO :: Flag
pattern $bFO :: Flag
$mFO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
FO = Flag 'F' 'O'
pattern FR :: Flag
pattern $bFR :: Flag
$mFR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
FR = Flag 'F' 'R'
pattern GA :: Flag
pattern $bGA :: Flag
$mGA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GA = Flag 'G' 'A'
pattern GB :: Flag
pattern $bGB :: Flag
$mGB :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GB = Flag 'G' 'B'
pattern GD :: Flag
pattern $bGD :: Flag
$mGD :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GD = Flag 'G' 'D'
pattern GE :: Flag
pattern $bGE :: Flag
$mGE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GE = Flag 'G' 'E'
pattern GF :: Flag
pattern $bGF :: Flag
$mGF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GF = Flag 'G' 'F'
pattern GG :: Flag
pattern $bGG :: Flag
$mGG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GG = Flag 'G' 'G'
pattern GH :: Flag
pattern $bGH :: Flag
$mGH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GH = Flag 'G' 'H'
pattern GI :: Flag
pattern $bGI :: Flag
$mGI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GI = Flag 'G' 'I'
pattern GL :: Flag
pattern $bGL :: Flag
$mGL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GL = Flag 'G' 'L'
pattern GM :: Flag
pattern $bGM :: Flag
$mGM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GM = Flag 'G' 'M'
pattern GN :: Flag
pattern $bGN :: Flag
$mGN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GN = Flag 'G' 'N'
pattern GP :: Flag
pattern $bGP :: Flag
$mGP :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GP = Flag 'G' 'P'
pattern GQ :: Flag
pattern $bGQ :: Flag
$mGQ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GQ = Flag 'G' 'Q'
pattern GR :: Flag
pattern $bGR :: Flag
$mGR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GR = Flag 'G' 'R'
pattern GS :: Flag
pattern $bGS :: Flag
$mGS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GS = Flag 'G' 'S'
pattern GT :: Flag
pattern $bGT :: Flag
$mGT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GT = Flag 'G' 'T'
pattern GU :: Flag
pattern $bGU :: Flag
$mGU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GU = Flag 'G' 'U'
pattern GW :: Flag
pattern $bGW :: Flag
$mGW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GW = Flag 'G' 'W'
pattern GY :: Flag
pattern $bGY :: Flag
$mGY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
GY = Flag 'G' 'Y'
pattern HK :: Flag
pattern $bHK :: Flag
$mHK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
HK = Flag 'H' 'K'
pattern HM :: Flag
pattern $bHM :: Flag
$mHM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
HM = Flag 'H' 'M'
pattern HN :: Flag
pattern $bHN :: Flag
$mHN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
HN = Flag 'H' 'N'
pattern HR :: Flag
pattern $bHR :: Flag
$mHR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
HR = Flag 'H' 'R'
pattern HT :: Flag
pattern $bHT :: Flag
$mHT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
HT = Flag 'H' 'T'
pattern HU :: Flag
pattern $bHU :: Flag
$mHU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
HU = Flag 'H' 'U'
pattern IC :: Flag
pattern $bIC :: Flag
$mIC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
IC = Flag 'I' 'C'
pattern ID :: Flag
pattern $bID :: Flag
$mID :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
ID = Flag 'I' 'D'
pattern IE :: Flag
pattern $bIE :: Flag
$mIE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
IE = Flag 'I' 'E'
pattern IL :: Flag
pattern $bIL :: Flag
$mIL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
IL = Flag 'I' 'L'
pattern IM :: Flag
pattern $bIM :: Flag
$mIM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
IM = Flag 'I' 'M'
pattern IN :: Flag
pattern $bIN :: Flag
$mIN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
IN = Flag 'I' 'N'
pattern IO :: Flag
pattern $bIO :: Flag
$mIO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
IO = Flag 'I' 'O'
pattern IQ :: Flag
pattern $bIQ :: Flag
$mIQ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
IQ = Flag 'I' 'Q'
pattern IR :: Flag
pattern $bIR :: Flag
$mIR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
IR = Flag 'I' 'R'
pattern IS :: Flag
pattern $bIS :: Flag
$mIS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
IS = Flag 'I' 'S'
pattern IT :: Flag
pattern $bIT :: Flag
$mIT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
IT = Flag 'I' 'T'
pattern JE :: Flag
pattern $bJE :: Flag
$mJE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
JE = Flag 'J' 'E'
pattern JM :: Flag
pattern $bJM :: Flag
$mJM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
JM = Flag 'J' 'M'
pattern JO :: Flag
pattern $bJO :: Flag
$mJO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
JO = Flag 'J' 'O'
pattern JP :: Flag
pattern $bJP :: Flag
$mJP :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
JP = Flag 'J' 'P'
pattern KE :: Flag
pattern $bKE :: Flag
$mKE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
KE = Flag 'K' 'E'
pattern KG :: Flag
pattern $bKG :: Flag
$mKG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
KG = Flag 'K' 'G'
pattern KH :: Flag
pattern $bKH :: Flag
$mKH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
KH = Flag 'K' 'H'
pattern KI :: Flag
pattern $bKI :: Flag
$mKI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
KI = Flag 'K' 'I'
pattern KM :: Flag
pattern $bKM :: Flag
$mKM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
KM = Flag 'K' 'M'
pattern KN :: Flag
pattern $bKN :: Flag
$mKN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
KN = Flag 'K' 'N'
pattern KP :: Flag
pattern $bKP :: Flag
$mKP :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
KP = Flag 'K' 'P'
pattern KR :: Flag
pattern $bKR :: Flag
$mKR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
KR = Flag 'K' 'R'
pattern KW :: Flag
pattern $bKW :: Flag
$mKW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
KW = Flag 'K' 'W'
pattern KY :: Flag
pattern $bKY :: Flag
$mKY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
KY = Flag 'K' 'Y'
pattern KZ :: Flag
pattern $bKZ :: Flag
$mKZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
KZ = Flag 'K' 'Z'
pattern LA :: Flag
pattern $bLA :: Flag
$mLA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
LA = Flag 'L' 'A'
pattern LB :: Flag
pattern $bLB :: Flag
$mLB :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
LB = Flag 'L' 'B'
pattern LC :: Flag
pattern $bLC :: Flag
$mLC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
LC = Flag 'L' 'C'
pattern LI :: Flag
pattern $bLI :: Flag
$mLI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
LI = Flag 'L' 'I'
pattern LK :: Flag
pattern $bLK :: Flag
$mLK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
LK = Flag 'L' 'K'
pattern LR :: Flag
pattern $bLR :: Flag
$mLR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
LR = Flag 'L' 'R'
pattern LS :: Flag
pattern $bLS :: Flag
$mLS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
LS = Flag 'L' 'S'
pattern LT :: Flag
pattern $bLT :: Flag
$mLT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
LT = Flag 'L' 'T'
pattern LU :: Flag
pattern $bLU :: Flag
$mLU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
LU = Flag 'L' 'U'
pattern LV :: Flag
pattern $bLV :: Flag
$mLV :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
LV = Flag 'L' 'V'
pattern LY :: Flag
pattern $bLY :: Flag
$mLY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
LY = Flag 'L' 'Y'
pattern MA :: Flag
pattern $bMA :: Flag
$mMA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MA = Flag 'M' 'A'
pattern MC :: Flag
pattern $bMC :: Flag
$mMC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MC = Flag 'M' 'C'
pattern MD :: Flag
pattern $bMD :: Flag
$mMD :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MD = Flag 'M' 'D'
pattern ME :: Flag
pattern $bME :: Flag
$mME :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
ME = Flag 'M' 'E'
pattern MF :: Flag
pattern $bMF :: Flag
$mMF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MF = Flag 'M' 'F'
pattern MG :: Flag
pattern $bMG :: Flag
$mMG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MG = Flag 'M' 'G'
pattern MH :: Flag
pattern $bMH :: Flag
$mMH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MH = Flag 'M' 'H'
pattern MK :: Flag
pattern $bMK :: Flag
$mMK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MK = Flag 'M' 'K'
pattern ML :: Flag
pattern $bML :: Flag
$mML :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
ML = Flag 'M' 'L'
pattern MM :: Flag
pattern $bMM :: Flag
$mMM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MM = Flag 'M' 'M'
pattern MN :: Flag
pattern $bMN :: Flag
$mMN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MN = Flag 'M' 'N'
pattern MO :: Flag
pattern $bMO :: Flag
$mMO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MO = Flag 'M' 'O'
pattern MP :: Flag
pattern $bMP :: Flag
$mMP :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MP = Flag 'M' 'P'
pattern MQ :: Flag
pattern $bMQ :: Flag
$mMQ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MQ = Flag 'M' 'Q'
pattern MR :: Flag
pattern $bMR :: Flag
$mMR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MR = Flag 'M' 'R'
pattern MS :: Flag
pattern $bMS :: Flag
$mMS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MS = Flag 'M' 'S'
pattern MT :: Flag
pattern $bMT :: Flag
$mMT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MT = Flag 'M' 'T'
pattern MU :: Flag
pattern $bMU :: Flag
$mMU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MU = Flag 'M' 'U'
pattern MV :: Flag
pattern $bMV :: Flag
$mMV :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MV = Flag 'M' 'V'
pattern MW :: Flag
pattern $bMW :: Flag
$mMW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MW = Flag 'M' 'W'
pattern MX :: Flag
pattern $bMX :: Flag
$mMX :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MX = Flag 'M' 'X'
pattern MY :: Flag
pattern $bMY :: Flag
$mMY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MY = Flag 'M' 'Y'
pattern MZ :: Flag
pattern $bMZ :: Flag
$mMZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
MZ = Flag 'M' 'Z'
pattern NA :: Flag
pattern $bNA :: Flag
$mNA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
NA = Flag 'N' 'A'
pattern NC :: Flag
pattern $bNC :: Flag
$mNC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
NC = Flag 'N' 'C'
pattern NE :: Flag
pattern $bNE :: Flag
$mNE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
NE = Flag 'N' 'E'
pattern NF :: Flag
pattern $bNF :: Flag
$mNF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
NF = Flag 'N' 'F'
pattern NG :: Flag
pattern $bNG :: Flag
$mNG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
NG = Flag 'N' 'G'
pattern NI :: Flag
pattern $bNI :: Flag
$mNI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
NI = Flag 'N' 'I'
pattern NL :: Flag
pattern $bNL :: Flag
$mNL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
NL = Flag 'N' 'L'
pattern NO :: Flag
pattern $bNO :: Flag
$mNO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
NO = Flag 'N' 'O'
pattern NP :: Flag
pattern $bNP :: Flag
$mNP :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
NP = Flag 'N' 'P'
pattern NR :: Flag
pattern $bNR :: Flag
$mNR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
NR = Flag 'N' 'R'
pattern NU :: Flag
pattern $bNU :: Flag
$mNU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
NU = Flag 'N' 'U'
pattern NZ :: Flag
pattern $bNZ :: Flag
$mNZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
NZ = Flag 'N' 'Z'
pattern OM :: Flag
pattern $bOM :: Flag
$mOM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
OM = Flag 'O' 'M'
pattern PA :: Flag
pattern $bPA :: Flag
$mPA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
PA = Flag 'P' 'A'
pattern PE :: Flag
pattern $bPE :: Flag
$mPE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
PE = Flag 'P' 'E'
pattern PF :: Flag
pattern $bPF :: Flag
$mPF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
PF = Flag 'P' 'F'
pattern PG :: Flag
pattern $bPG :: Flag
$mPG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
PG = Flag 'P' 'G'
pattern PH :: Flag
pattern $bPH :: Flag
$mPH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
PH = Flag 'P' 'H'
pattern PK :: Flag
pattern $bPK :: Flag
$mPK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
PK = Flag 'P' 'K'
pattern PL :: Flag
pattern $bPL :: Flag
$mPL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
PL = Flag 'P' 'L'
pattern PM :: Flag
pattern $bPM :: Flag
$mPM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
PM = Flag 'P' 'M'
pattern PN :: Flag
pattern $bPN :: Flag
$mPN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
PN = Flag 'P' 'N'
pattern PR :: Flag
pattern $bPR :: Flag
$mPR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
PR = Flag 'P' 'R'
pattern PS :: Flag
pattern $bPS :: Flag
$mPS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
PS = Flag 'P' 'S'
pattern PT :: Flag
pattern $bPT :: Flag
$mPT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
PT = Flag 'P' 'T'
pattern PW :: Flag
pattern $bPW :: Flag
$mPW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
PW = Flag 'P' 'W'
pattern PY :: Flag
pattern $bPY :: Flag
$mPY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
PY = Flag 'P' 'Y'
pattern QA :: Flag
pattern $bQA :: Flag
$mQA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
QA = Flag 'Q' 'A'
pattern RE :: Flag
pattern $bRE :: Flag
$mRE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
RE = Flag 'R' 'E'
pattern RO :: Flag
pattern $bRO :: Flag
$mRO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
RO = Flag 'R' 'O'
pattern RS :: Flag
pattern $bRS :: Flag
$mRS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
RS = Flag 'R' 'S'
pattern RU :: Flag
pattern $bRU :: Flag
$mRU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
RU = Flag 'R' 'U'
pattern RW :: Flag
pattern $bRW :: Flag
$mRW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
RW = Flag 'R' 'W'
pattern SA :: Flag
pattern $bSA :: Flag
$mSA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SA = Flag 'S' 'A'
pattern SB :: Flag
pattern $bSB :: Flag
$mSB :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SB = Flag 'S' 'B'
pattern SC :: Flag
pattern $bSC :: Flag
$mSC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SC = Flag 'S' 'C'
pattern SD :: Flag
pattern $bSD :: Flag
$mSD :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SD = Flag 'S' 'D'
pattern SE :: Flag
pattern $bSE :: Flag
$mSE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SE = Flag 'S' 'E'
pattern SG :: Flag
pattern $bSG :: Flag
$mSG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SG = Flag 'S' 'G'
pattern SH :: Flag
pattern $bSH :: Flag
$mSH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SH = Flag 'S' 'H'
pattern SI :: Flag
pattern $bSI :: Flag
$mSI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SI = Flag 'S' 'I'
pattern SJ :: Flag
pattern $bSJ :: Flag
$mSJ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SJ = Flag 'S' 'J'
pattern SK :: Flag
pattern $bSK :: Flag
$mSK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SK = Flag 'S' 'K'
pattern SL :: Flag
pattern $bSL :: Flag
$mSL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SL = Flag 'S' 'L'
pattern SM :: Flag
pattern $bSM :: Flag
$mSM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SM = Flag 'S' 'M'
pattern SN :: Flag
pattern $bSN :: Flag
$mSN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SN = Flag 'S' 'N'
pattern SO :: Flag
pattern $bSO :: Flag
$mSO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SO = Flag 'S' 'O'
pattern SR :: Flag
pattern $bSR :: Flag
$mSR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SR = Flag 'S' 'R'
pattern SS :: Flag
pattern $bSS :: Flag
$mSS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SS = Flag 'S' 'S'
pattern ST :: Flag
pattern $bST :: Flag
$mST :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
ST = Flag 'S' 'T'
pattern SV :: Flag
pattern $bSV :: Flag
$mSV :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SV = Flag 'S' 'V'
pattern SX :: Flag
pattern $bSX :: Flag
$mSX :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SX = Flag 'S' 'X'
pattern SY :: Flag
pattern $bSY :: Flag
$mSY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SY = Flag 'S' 'Y'
pattern SZ :: Flag
pattern $bSZ :: Flag
$mSZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
SZ = Flag 'S' 'Z'
pattern TA :: Flag
pattern $bTA :: Flag
$mTA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
TA = Flag 'T' 'A'
pattern TC :: Flag
pattern $bTC :: Flag
$mTC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
TC = Flag 'T' 'C'
pattern TD :: Flag
pattern $bTD :: Flag
$mTD :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
TD = Flag 'T' 'D'
pattern TF :: Flag
pattern $bTF :: Flag
$mTF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
TF = Flag 'T' 'F'
pattern TG :: Flag
pattern $bTG :: Flag
$mTG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
TG = Flag 'T' 'G'
pattern TH :: Flag
pattern $bTH :: Flag
$mTH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
TH = Flag 'T' 'H'
pattern TJ :: Flag
pattern $bTJ :: Flag
$mTJ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
TJ = Flag 'T' 'J'
pattern TK :: Flag
pattern $bTK :: Flag
$mTK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
TK = Flag 'T' 'K'
pattern TL :: Flag
pattern $bTL :: Flag
$mTL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
TL = Flag 'T' 'L'
pattern TM :: Flag
pattern $bTM :: Flag
$mTM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
TM = Flag 'T' 'M'
pattern TN :: Flag
pattern $bTN :: Flag
$mTN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
TN = Flag 'T' 'N'
pattern TO :: Flag
pattern $bTO :: Flag
$mTO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
TO = Flag 'T' 'O'
pattern TR :: Flag
pattern $bTR :: Flag
$mTR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
TR = Flag 'T' 'R'
pattern TT :: Flag
pattern $bTT :: Flag
$mTT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
TT = Flag 'T' 'T'
pattern TV :: Flag
pattern $bTV :: Flag
$mTV :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
TV = Flag 'T' 'V'
pattern TW :: Flag
pattern $bTW :: Flag
$mTW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
TW = Flag 'T' 'W'
pattern TZ :: Flag
pattern $bTZ :: Flag
$mTZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
TZ = Flag 'T' 'Z'
pattern UA :: Flag
pattern $bUA :: Flag
$mUA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
UA = Flag 'U' 'A'
pattern UG :: Flag
pattern $bUG :: Flag
$mUG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
UG = Flag 'U' 'G'
pattern UM :: Flag
pattern $bUM :: Flag
$mUM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
UM = Flag 'U' 'M'
pattern UN :: Flag
pattern $bUN :: Flag
$mUN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
UN = Flag 'U' 'N'
pattern US :: Flag
pattern $bUS :: Flag
$mUS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
US = Flag 'U' 'S'
pattern UY :: Flag
pattern $bUY :: Flag
$mUY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
UY = Flag 'U' 'Y'
pattern UZ :: Flag
pattern $bUZ :: Flag
$mUZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
UZ = Flag 'U' 'Z'
pattern VA :: Flag
pattern $bVA :: Flag
$mVA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
VA = Flag 'V' 'A'
pattern VC :: Flag
pattern $bVC :: Flag
$mVC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
VC = Flag 'V' 'C'
pattern VE :: Flag
pattern $bVE :: Flag
$mVE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
VE = Flag 'V' 'E'
pattern VG :: Flag
pattern $bVG :: Flag
$mVG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
VG = Flag 'V' 'G'
pattern VI :: Flag
pattern $bVI :: Flag
$mVI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
VI = Flag 'V' 'I'
pattern VN :: Flag
pattern $bVN :: Flag
$mVN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
VN = Flag 'V' 'N'
pattern VU :: Flag
pattern $bVU :: Flag
$mVU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
VU = Flag 'V' 'U'
pattern WF :: Flag
pattern $bWF :: Flag
$mWF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
WF = Flag 'W' 'F'
pattern WS :: Flag
pattern $bWS :: Flag
$mWS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
WS = Flag 'W' 'S'
pattern XK :: Flag
pattern $bXK :: Flag
$mXK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
XK = Flag 'X' 'K'
pattern YE :: Flag
pattern $bYE :: Flag
$mYE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
YE = Flag 'Y' 'E'
pattern YT :: Flag
pattern $bYT :: Flag
$mYT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
YT = Flag 'Y' 'T'
pattern ZA :: Flag
pattern $bZA :: Flag
$mZA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
ZA = Flag 'Z' 'A'
pattern ZM :: Flag
pattern $bZM :: Flag
$mZM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
ZM = Flag 'Z' 'M'
pattern ZW :: Flag
pattern $bZW :: Flag
$mZW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
ZW = Flag 'Z' 'W'
pattern GBSubFlag :: Char -> Char -> Char -> SubFlag
pattern $bGBSubFlag :: Char -> Char -> Char -> SubFlag
$mGBSubFlag :: forall {r}.
SubFlag -> (Char -> Char -> Char -> r) -> ((# #) -> r) -> r
GBSubFlag a b c = SubFlag GB a b (Just c)
pattern USSubFlag :: Char -> Char -> SubFlag
pattern $bUSSubFlag :: Char -> Char -> SubFlag
$mUSSubFlag :: forall {r}. SubFlag -> (Char -> Char -> r) -> ((# #) -> r) -> r
USSubFlag a b = SubFlag US a b Nothing
pattern ENG :: SubFlag
pattern $bENG :: SubFlag
$mENG :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
ENG = GBSubFlag 'e' 'n' 'g'
pattern SCT :: SubFlag
pattern $bSCT :: SubFlag
$mSCT :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
SCT = GBSubFlag 's' 'c' 't'
pattern WLS :: SubFlag
pattern $bWLS :: SubFlag
$mWLS :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
WLS = GBSubFlag 'w' 'l' 's'
pattern USAL :: SubFlag
pattern $bUSAL :: SubFlag
$mUSAL :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USAL = USSubFlag 'a' 'l'
pattern USAK :: SubFlag
pattern $bUSAK :: SubFlag
$mUSAK :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USAK = USSubFlag 'a' 'k'
pattern USAS :: SubFlag
pattern $bUSAS :: SubFlag
$mUSAS :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USAS = USSubFlag 'a' 's'
pattern USAZ :: SubFlag
pattern $bUSAZ :: SubFlag
$mUSAZ :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USAZ = USSubFlag 'a' 'z'
pattern USAR :: SubFlag
pattern $bUSAR :: SubFlag
$mUSAR :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USAR = USSubFlag 'a' 'r'
pattern USCA :: SubFlag
pattern $bUSCA :: SubFlag
$mUSCA :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USCA = USSubFlag 'c' 'a'
pattern USCO :: SubFlag
pattern $bUSCO :: SubFlag
$mUSCO :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USCO = USSubFlag 'c' 'o'
pattern USCT :: SubFlag
pattern $bUSCT :: SubFlag
$mUSCT :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USCT = USSubFlag 'c' 't'
pattern USDE :: SubFlag
pattern $bUSDE :: SubFlag
$mUSDE :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USDE = USSubFlag 'd' 'e'
pattern USFL :: SubFlag
pattern $bUSFL :: SubFlag
$mUSFL :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USFL = USSubFlag 'f' 'l'
pattern USGA :: SubFlag
pattern $bUSGA :: SubFlag
$mUSGA :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USGA = USSubFlag 'g' 'a'
pattern USGU :: SubFlag
pattern $bUSGU :: SubFlag
$mUSGU :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USGU = USSubFlag 'g' 'u'
pattern USHI :: SubFlag
pattern $bUSHI :: SubFlag
$mUSHI :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USHI = USSubFlag 'h' 'i'
pattern USID :: SubFlag
pattern $bUSID :: SubFlag
$mUSID :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USID = USSubFlag 'i' 'd'
pattern USIL :: SubFlag
pattern $bUSIL :: SubFlag
$mUSIL :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USIL = USSubFlag 'i' 'l'
pattern USIN :: SubFlag
pattern $bUSIN :: SubFlag
$mUSIN :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USIN = USSubFlag 'i' 'n'
pattern USIA :: SubFlag
pattern $bUSIA :: SubFlag
$mUSIA :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USIA = USSubFlag 'i' 'a'
pattern USKS :: SubFlag
pattern $bUSKS :: SubFlag
$mUSKS :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USKS = USSubFlag 'k' 's'
pattern USKY :: SubFlag
pattern $bUSKY :: SubFlag
$mUSKY :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USKY = USSubFlag 'k' 'y'
pattern USLA :: SubFlag
pattern $bUSLA :: SubFlag
$mUSLA :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USLA = USSubFlag 'l' 'a'
pattern USME :: SubFlag
pattern $bUSME :: SubFlag
$mUSME :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USME = USSubFlag 'm' 'e'
pattern USMD :: SubFlag
pattern $bUSMD :: SubFlag
$mUSMD :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USMD = USSubFlag 'm' 'd'
pattern USMA :: SubFlag
pattern $bUSMA :: SubFlag
$mUSMA :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USMA = USSubFlag 'm' 'a'
pattern USMI :: SubFlag
pattern $bUSMI :: SubFlag
$mUSMI :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USMI = USSubFlag 'm' 'i'
pattern USMN :: SubFlag
pattern $bUSMN :: SubFlag
$mUSMN :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USMN = USSubFlag 'm' 'n'
pattern USMS :: SubFlag
pattern $bUSMS :: SubFlag
$mUSMS :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USMS = USSubFlag 'm' 's'
pattern USMO :: SubFlag
pattern $bUSMO :: SubFlag
$mUSMO :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USMO = USSubFlag 'm' 'o'
pattern USMT :: SubFlag
pattern $bUSMT :: SubFlag
$mUSMT :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USMT = USSubFlag 'm' 't'
pattern USNE :: SubFlag
pattern $bUSNE :: SubFlag
$mUSNE :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USNE = USSubFlag 'n' 'e'
pattern USNV :: SubFlag
pattern $bUSNV :: SubFlag
$mUSNV :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USNV = USSubFlag 'n' 'v'
pattern USNH :: SubFlag
pattern $bUSNH :: SubFlag
$mUSNH :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USNH = USSubFlag 'n' 'h'
pattern USNJ :: SubFlag
pattern $bUSNJ :: SubFlag
$mUSNJ :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USNJ = USSubFlag 'n' 'j'
pattern USNM :: SubFlag
pattern $bUSNM :: SubFlag
$mUSNM :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USNM = USSubFlag 'n' 'm'
pattern USNY :: SubFlag
pattern $bUSNY :: SubFlag
$mUSNY :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USNY = USSubFlag 'n' 'y'
pattern USNC :: SubFlag
pattern $bUSNC :: SubFlag
$mUSNC :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USNC = USSubFlag 'n' 'c'
pattern USND :: SubFlag
pattern $bUSND :: SubFlag
$mUSND :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USND = USSubFlag 'n' 'd'
pattern USMP :: SubFlag
pattern $bUSMP :: SubFlag
$mUSMP :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USMP = USSubFlag 'm' 'p'
pattern USOH :: SubFlag
pattern $bUSOH :: SubFlag
$mUSOH :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USOH = USSubFlag 'o' 'h'
pattern USOK :: SubFlag
pattern $bUSOK :: SubFlag
$mUSOK :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USOK = USSubFlag 'o' 'k'
pattern USOR :: SubFlag
pattern $bUSOR :: SubFlag
$mUSOR :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USOR = USSubFlag 'o' 'r'
pattern USPA :: SubFlag
pattern $bUSPA :: SubFlag
$mUSPA :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USPA = USSubFlag 'p' 'a'
pattern USPR :: SubFlag
pattern $bUSPR :: SubFlag
$mUSPR :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USPR = USSubFlag 'p' 'r'
pattern USRI :: SubFlag
pattern $bUSRI :: SubFlag
$mUSRI :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USRI = USSubFlag 'r' 'i'
pattern USSC :: SubFlag
pattern $bUSSC :: SubFlag
$mUSSC :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USSC = USSubFlag 's' 'c'
pattern USSD :: SubFlag
pattern $bUSSD :: SubFlag
$mUSSD :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USSD = USSubFlag 's' 'd'
pattern USTN :: SubFlag
pattern $bUSTN :: SubFlag
$mUSTN :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USTN = USSubFlag 't' 'n'
pattern USUM :: SubFlag
pattern $bUSUM :: SubFlag
$mUSUM :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USUM = USSubFlag 'u' 'm'
pattern USVI :: SubFlag
pattern $bUSVI :: SubFlag
$mUSVI :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USVI = USSubFlag 'v' 'i'
pattern USUT :: SubFlag
pattern $bUSUT :: SubFlag
$mUSUT :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USUT = USSubFlag 'u' 't'
pattern USVT :: SubFlag
pattern $bUSVT :: SubFlag
$mUSVT :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USVT = USSubFlag 'v' 't'
pattern USVA :: SubFlag
pattern $bUSVA :: SubFlag
$mUSVA :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USVA = USSubFlag 'v' 'a'
pattern USWA :: SubFlag
pattern $bUSWA :: SubFlag
$mUSWA :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USWA = USSubFlag 'w' 'a'
pattern USDC :: SubFlag
pattern $bUSDC :: SubFlag
$mUSDC :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USDC = USSubFlag 'd' 'c'
pattern USWV :: SubFlag
pattern $bUSWV :: SubFlag
$mUSWV :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USWV = USSubFlag 'w' 'v'
pattern USWI :: SubFlag
pattern $bUSWI :: SubFlag
$mUSWI :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USWI = USSubFlag 'w' 'i'
pattern USWY :: SubFlag
pattern $bUSWY :: SubFlag
$mUSWY :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
USWY = USSubFlag 'w' 'y'
instance Bounded SubFlag where
minBound :: SubFlag
minBound = forall a. [a] -> a
head [SubFlag]
_subflags
maxBound :: SubFlag
maxBound = forall a. [a] -> a
last [SubFlag]
_subflags
iso3166Alpha2ToFlag' ::
Char ->
Char ->
Text
iso3166Alpha2ToFlag' :: Char -> Char -> Text
iso3166Alpha2ToFlag' Char
ca Char
cb = String -> Text
pack (forall a b. (a -> b) -> [a] -> [b]
map (Char -> Char
regionalIndicatorUppercase' forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char
toUpper) [Char
ca, Char
cb])
iso3166Alpha2ToFlag ::
Char ->
Char ->
Maybe Text
iso3166Alpha2ToFlag :: Char -> Char -> Maybe Text
iso3166Alpha2ToFlag Char
ca Char
cb
| Char -> Char -> Bool
validFlagEmoji Char
ca Char
cb = forall a. a -> Maybe a
Just (Char -> Char -> Text
iso3166Alpha2ToFlag' Char
ca Char
cb)
| Bool
otherwise = forall a. Maybe a
Nothing
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 = forall a. a -> Maybe a
Just (Char -> Char -> Flag
Flag Char
a Char
b)
| Bool
otherwise = forall a. Maybe a
Nothing
where
shft :: Char -> Maybe Char
shft = forall a. (Bounded a, Enum a) => Int -> Char -> Maybe a
mapToEnumSafe Int
_flagCharOffset
validFlagEmoji ::
Char ->
Char ->
Bool
validFlagEmoji :: Char -> Char -> Bool
validFlagEmoji = 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 Flag where
arbitrary :: Gen Flag
arbitrary = forall a. (Bounded a, Enum a) => Gen a
arbitraryBoundedEnum
instance Arbitrary SubFlag where
arbitrary :: Gen SubFlag
arbitrary = forall a. [a] -> Gen a
elements [SubFlag]
_subflags
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 = 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 = forall a b. Show a => String -> Int -> (a, a) -> b
toEnumError String
"Flag" Int
i (forall a. Bounded a => a
minBound :: Flag, forall a. Bounded a => a
maxBound)
enumFrom :: Flag -> [Flag]
enumFrom = (forall a. Enum a => a -> a -> [a]
`enumFromTo` forall a. Bounded a => a
maxBound)
enumFromThen :: Flag -> Flag -> [Flag]
enumFromThen Flag
x Flag
y = forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo Flag
x Flag
y forall a. Bounded a => a
maxBound
_subflags :: [SubFlag]
_subflags :: [SubFlag]
_subflags = [SubFlag
ENG, SubFlag
SCT, SubFlag
WLS, SubFlag
USAL, SubFlag
USAK, SubFlag
USAS, SubFlag
USAZ, SubFlag
USAR, SubFlag
USCA, SubFlag
USCO, SubFlag
USCT, SubFlag
USDE, SubFlag
USFL, SubFlag
USGA, SubFlag
USGU, SubFlag
USHI, SubFlag
USID, SubFlag
USIL, SubFlag
USIN, SubFlag
USIA, SubFlag
USKS, SubFlag
USKY, SubFlag
USLA, SubFlag
USME, SubFlag
USMD, SubFlag
USMA, SubFlag
USMI, SubFlag
USMN, SubFlag
USMS, SubFlag
USMO, SubFlag
USMT, SubFlag
USNE, SubFlag
USNV, SubFlag
USNH, SubFlag
USNJ, SubFlag
USNM, SubFlag
USNY, SubFlag
USNC, SubFlag
USND, SubFlag
USMP, SubFlag
USOH, SubFlag
USOK, SubFlag
USOR, SubFlag
USPA, SubFlag
USPR, SubFlag
USRI, SubFlag
USSC, SubFlag
USSD, SubFlag
USTN, SubFlag
USUM, SubFlag
USVI, SubFlag
USUT, SubFlag
USVT, SubFlag
USVA, SubFlag
USWA, SubFlag
USDC, SubFlag
USWV, SubFlag
USWI, SubFlag
USWY]
(?!) :: Int -> [a] -> Maybe a
?! :: forall a. Int -> [a] -> Maybe a
(?!) Int
n
| Int
n forall a. Ord a => a -> a -> Bool
< Int
0 = forall a b. a -> b -> a
const forall a. Maybe a
Nothing
| Bool
otherwise = forall {t} {a}. (Eq t, Num t) => t -> [a] -> Maybe a
go Int
n
where
go :: t -> [a] -> Maybe a
go t
0 (a
x : [a]
_) = forall a. a -> Maybe a
Just a
x
go t
i (a
_ : [a]
xs) = t -> [a] -> Maybe a
go (t
i forall a. Num a => a -> a -> a
- t
1) [a]
xs
go t
_ [] = forall a. Maybe a
Nothing
instance Enum SubFlag where
fromEnum :: SubFlag -> Int
fromEnum SubFlag
s = forall a. a -> Maybe a -> a
fromMaybe (forall a b. Show a => String -> a -> b
fromEnumError String
"SubFlag" SubFlag
s) (forall a. Eq a => a -> [a] -> Maybe Int
elemIndex SubFlag
s [SubFlag]
_subflags)
toEnum :: Int -> SubFlag
toEnum Int
i = forall a. a -> Maybe a -> a
fromMaybe (forall a b. Show a => String -> Int -> (a, a) -> b
toEnumError String
"SubFlag" Int
i (forall a. Bounded a => a
minBound :: SubFlag, forall a. Bounded a => a
maxBound)) (Int
i forall a. Int -> [a] -> Maybe a
?! [SubFlag]
_subflags)
enumFrom :: SubFlag -> [SubFlag]
enumFrom = (forall a. Enum a => a -> a -> [a]
`enumFromTo` forall a. Bounded a => a
maxBound)
enumFromThen :: SubFlag -> SubFlag -> [SubFlag]
enumFromThen SubFlag
x SubFlag
y = forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo SubFlag
x SubFlag
y forall a. Bounded a => a
maxBound
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
isInTextRange :: Text -> Bool
isInTextRange Text
c
| [Char
ca, Char
cb] <- Text -> String
unpack Text
c, Just Char
a <- Char -> Maybe Char
shft Char
ca, Just Char
b <- Char -> Maybe Char
shft Char
cb = Char -> Char -> Bool
_validFlagEmoji Char
a Char
b
| Bool
otherwise = Bool
False
where
shft :: Char -> Maybe Char
shft = forall a. (Bounded a, Enum a) => Int -> Char -> Maybe a
mapToEnumSafe Int
_flagCharOffset
instance UnicodeText SubFlag where
toUnicodeText :: SubFlag -> Text
toUnicodeText (SubFlag (Flag Char
ca Char
cb) Char
cc Char
cd Maybe Char
ce) = String -> Text
pack (Char
'\x1f3f4' forall a. a -> [a] -> [a]
: Char -> Char
go' Char
ca forall a. a -> [a] -> [a]
: Char -> Char
go' Char
cb forall a. a -> [a] -> [a]
: forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
go (Char
cc forall a. a -> [a] -> [a]
: Char
cd forall a. a -> [a] -> [a]
: forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall a. a -> a
id (:) Maybe Char
ce String
"\DEL"))
where
go :: Char -> Char
go = Int -> Char
chr forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int
0xe0000 forall a. Bits a => a -> a -> a
.|.) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
ord
go' :: Char -> Char
go' = Char -> Char
go forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char
toLower
fromUnicodeText :: Text -> Maybe SubFlag
fromUnicodeText Text
t = forall a. [a] -> Maybe a
listToMaybe [SubFlag
sf | SubFlag
sf <- [SubFlag]
_subflags, Text
t forall a. Eq a => a -> a -> Bool
== forall a. UnicodeText a => a -> Text
toUnicodeText SubFlag
sf]
isInTextRange :: Text -> Bool
isInTextRange = (forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` forall a b. (a -> b) -> [a] -> [b]
map forall a. UnicodeText a => a -> Text
toUnicodeText [SubFlag]
_subflags)
data
=
ChequeredFlag
|
TriangularFlagOnPost
|
CrossedFlags
|
BlackFlag
|
WavingWhiteFlag
|
RainbowFlag
|
TransgenderFlag
|
PirateFlag
deriving (ExtraFlag
forall a. a -> a -> Bounded a
maxBound :: ExtraFlag
$cmaxBound :: ExtraFlag
minBound :: ExtraFlag
$cminBound :: ExtraFlag
Bounded, Typeable ExtraFlag
ExtraFlag -> DataType
ExtraFlag -> Constr
(forall b. Data b => b -> b) -> ExtraFlag -> ExtraFlag
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) -> ExtraFlag -> u
forall u. (forall d. Data d => d -> u) -> ExtraFlag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraFlag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraFlag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExtraFlag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExtraFlag -> c ExtraFlag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExtraFlag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExtraFlag)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExtraFlag -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExtraFlag -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ExtraFlag -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ExtraFlag -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraFlag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraFlag -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraFlag -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraFlag -> r
gmapT :: (forall b. Data b => b -> b) -> ExtraFlag -> ExtraFlag
$cgmapT :: (forall b. Data b => b -> b) -> ExtraFlag -> ExtraFlag
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExtraFlag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExtraFlag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExtraFlag)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExtraFlag)
dataTypeOf :: ExtraFlag -> DataType
$cdataTypeOf :: ExtraFlag -> DataType
toConstr :: ExtraFlag -> Constr
$ctoConstr :: ExtraFlag -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExtraFlag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExtraFlag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExtraFlag -> c ExtraFlag
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExtraFlag -> c ExtraFlag
Data, Int -> ExtraFlag
ExtraFlag -> Int
ExtraFlag -> [ExtraFlag]
ExtraFlag -> ExtraFlag
ExtraFlag -> ExtraFlag -> [ExtraFlag]
ExtraFlag -> ExtraFlag -> ExtraFlag -> [ExtraFlag]
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 :: ExtraFlag -> ExtraFlag -> ExtraFlag -> [ExtraFlag]
$cenumFromThenTo :: ExtraFlag -> ExtraFlag -> ExtraFlag -> [ExtraFlag]
enumFromTo :: ExtraFlag -> ExtraFlag -> [ExtraFlag]
$cenumFromTo :: ExtraFlag -> ExtraFlag -> [ExtraFlag]
enumFromThen :: ExtraFlag -> ExtraFlag -> [ExtraFlag]
$cenumFromThen :: ExtraFlag -> ExtraFlag -> [ExtraFlag]
enumFrom :: ExtraFlag -> [ExtraFlag]
$cenumFrom :: ExtraFlag -> [ExtraFlag]
fromEnum :: ExtraFlag -> Int
$cfromEnum :: ExtraFlag -> Int
toEnum :: Int -> ExtraFlag
$ctoEnum :: Int -> ExtraFlag
pred :: ExtraFlag -> ExtraFlag
$cpred :: ExtraFlag -> ExtraFlag
succ :: ExtraFlag -> ExtraFlag
$csucc :: ExtraFlag -> ExtraFlag
Enum, ExtraFlag -> ExtraFlag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExtraFlag -> ExtraFlag -> Bool
$c/= :: ExtraFlag -> ExtraFlag -> Bool
== :: ExtraFlag -> ExtraFlag -> Bool
$c== :: ExtraFlag -> ExtraFlag -> Bool
Eq, forall x. Rep ExtraFlag x -> ExtraFlag
forall x. ExtraFlag -> Rep ExtraFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ExtraFlag x -> ExtraFlag
$cfrom :: forall x. ExtraFlag -> Rep ExtraFlag x
Generic, Eq ExtraFlag
ExtraFlag -> ExtraFlag -> Bool
ExtraFlag -> ExtraFlag -> Ordering
ExtraFlag -> ExtraFlag -> ExtraFlag
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 :: ExtraFlag -> ExtraFlag -> ExtraFlag
$cmin :: ExtraFlag -> ExtraFlag -> ExtraFlag
max :: ExtraFlag -> ExtraFlag -> ExtraFlag
$cmax :: ExtraFlag -> ExtraFlag -> ExtraFlag
>= :: ExtraFlag -> ExtraFlag -> Bool
$c>= :: ExtraFlag -> ExtraFlag -> Bool
> :: ExtraFlag -> ExtraFlag -> Bool
$c> :: ExtraFlag -> ExtraFlag -> Bool
<= :: ExtraFlag -> ExtraFlag -> Bool
$c<= :: ExtraFlag -> ExtraFlag -> Bool
< :: ExtraFlag -> ExtraFlag -> Bool
$c< :: ExtraFlag -> ExtraFlag -> Bool
compare :: ExtraFlag -> ExtraFlag -> Ordering
$ccompare :: ExtraFlag -> ExtraFlag -> Ordering
Ord, ReadPrec [ExtraFlag]
ReadPrec ExtraFlag
Int -> ReadS ExtraFlag
ReadS [ExtraFlag]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ExtraFlag]
$creadListPrec :: ReadPrec [ExtraFlag]
readPrec :: ReadPrec ExtraFlag
$creadPrec :: ReadPrec ExtraFlag
readList :: ReadS [ExtraFlag]
$creadList :: ReadS [ExtraFlag]
readsPrec :: Int -> ReadS ExtraFlag
$creadsPrec :: Int -> ReadS ExtraFlag
Read, Int -> ExtraFlag -> ShowS
[ExtraFlag] -> ShowS
ExtraFlag -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExtraFlag] -> ShowS
$cshowList :: [ExtraFlag] -> ShowS
show :: ExtraFlag -> String
$cshow :: ExtraFlag -> String
showsPrec :: Int -> ExtraFlag -> ShowS
$cshowsPrec :: Int -> ExtraFlag -> ShowS
Show)
instance Arbitrary ExtraFlag where
arbitrary :: Gen ExtraFlag
arbitrary = forall a. (Bounded a, Enum a) => Gen a
arbitraryBoundedEnum
instance Hashable ExtraFlag
instance NFData ExtraFlag
instance UnicodeText ExtraFlag where
toUnicodeText :: ExtraFlag -> Text
toUnicodeText ExtraFlag
ChequeredFlag = Text
"\x1f3c1"
toUnicodeText ExtraFlag
TriangularFlagOnPost = Text
"\x1f6a9"
toUnicodeText ExtraFlag
CrossedFlags = Text
"\x1f38c"
toUnicodeText ExtraFlag
BlackFlag = Text
"\x1f3f4"
toUnicodeText ExtraFlag
WavingWhiteFlag = Text
"\x1f3f3\xfe0f"
toUnicodeText ExtraFlag
RainbowFlag = Text
"\x1f3f3\xfe0f\x200d\x1f308"
toUnicodeText ExtraFlag
TransgenderFlag = Text
"\x1f3f3\xfe0f\x200d\x26a7\xfe0f"
toUnicodeText ExtraFlag
PirateFlag = Text
"\x1f3f4\x200d\x2620\xfe0f"
fromUnicodeText :: Text -> Maybe ExtraFlag
fromUnicodeText Text
"\x1f3c1" = forall a. a -> Maybe a
Just ExtraFlag
ChequeredFlag
fromUnicodeText Text
"\x1f6a9" = forall a. a -> Maybe a
Just ExtraFlag
TriangularFlagOnPost
fromUnicodeText Text
"\x1f38c" = forall a. a -> Maybe a
Just ExtraFlag
CrossedFlags
fromUnicodeText Text
"\x1f3f4" = forall a. a -> Maybe a
Just ExtraFlag
BlackFlag
fromUnicodeText Text
"\x1f3f3\xfe0f" = forall a. a -> Maybe a
Just ExtraFlag
WavingWhiteFlag
fromUnicodeText Text
"\x1f3f3\xfe0f\x200d\x1f308" = forall a. a -> Maybe a
Just ExtraFlag
RainbowFlag
fromUnicodeText Text
"\x1f3f3\xfe0f\x200d\x26a7\xfe0f" = forall a. a -> Maybe a
Just ExtraFlag
TransgenderFlag
fromUnicodeText Text
"\x1f3f4\x200d\x2620\xfe0f" = forall a. a -> Maybe a
Just ExtraFlag
PirateFlag
fromUnicodeText Text
_ = forall a. Maybe a
Nothing
isInTextRange :: Text -> Bool
isInTextRange Text
"\x1f3c1" = Bool
True
isInTextRange Text
"\x1f6a9" = Bool
True
isInTextRange Text
"\x1f38c" = Bool
True
isInTextRange Text
"\x1f3f4" = Bool
True
isInTextRange Text
"\x1f3f3\xfe0f" = Bool
True
isInTextRange Text
"\x1f3f3\xfe0f\x200d\x1f308" = Bool
True
isInTextRange Text
"\x1f3f3\xfe0f\x200d\x26a7\xfe0f" = Bool
True
isInTextRange Text
"\x1f3f4\x200d\x2620\xfe0f" = Bool
True
isInTextRange Text
_ = Bool
False