{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE Safe #-}
{-# LANGUAGE TypeApplications #-}

-- |
-- Module      : Data.Char.Emoji.Gender
-- Description : A module that defines emoji that deal with gender.
-- Maintainer  : hapytexeu+gh@gmail.com
-- Stability   : experimental
-- Portability : POSIX
--
-- Unicode has two emoji to express male and/or female. These
-- emoji are also used as modifiers for other emoji.
module Data.Char.Emoji.Gender
  ( -- * Gender sign emoji
    BinaryGender (Female, Male),
    Trigender (Binary, Transgender),
  )
where

import Control.DeepSeq (NFData)
import Data.Char.Core (UnicodeText (fromUnicodeText, isInTextRange, toUnicodeText))
import Data.Data (Data)
import Data.Hashable (Hashable)
import GHC.Generics (Generic)
import Test.QuickCheck.Arbitrary (Arbitrary (arbitrary), arbitraryBoundedEnum)

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

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

instance Hashable BinaryGender

instance NFData BinaryGender

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

-- | A data type that, besides 'Male' and 'Female' can also represent a 'Transgender'.
data Trigender
  = -- | Specify a /binary/ gender which is /female/ or /male/.
    Binary BinaryGender
  | -- | A value that specifies a /transgender/, this is denoted with ⚧️.
    Transgender
  deriving (Typeable Trigender
Trigender -> DataType
Trigender -> Constr
(forall b. Data b => b -> b) -> Trigender -> Trigender
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) -> Trigender -> u
forall u. (forall d. Data d => d -> u) -> Trigender -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Trigender -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Trigender -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Trigender -> m Trigender
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Trigender -> m Trigender
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Trigender
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Trigender -> c Trigender
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Trigender)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Trigender)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Trigender -> m Trigender
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Trigender -> m Trigender
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Trigender -> m Trigender
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Trigender -> m Trigender
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Trigender -> m Trigender
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Trigender -> m Trigender
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Trigender -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Trigender -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Trigender -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Trigender -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Trigender -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Trigender -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Trigender -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Trigender -> r
gmapT :: (forall b. Data b => b -> b) -> Trigender -> Trigender
$cgmapT :: (forall b. Data b => b -> b) -> Trigender -> Trigender
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Trigender)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Trigender)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Trigender)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Trigender)
dataTypeOf :: Trigender -> DataType
$cdataTypeOf :: Trigender -> DataType
toConstr :: Trigender -> Constr
$ctoConstr :: Trigender -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Trigender
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Trigender
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Trigender -> c Trigender
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Trigender -> c Trigender
Data, Trigender -> Trigender -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Trigender -> Trigender -> Bool
$c/= :: Trigender -> Trigender -> Bool
== :: Trigender -> Trigender -> Bool
$c== :: Trigender -> Trigender -> Bool
Eq, forall x. Rep Trigender x -> Trigender
forall x. Trigender -> Rep Trigender x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Trigender x -> Trigender
$cfrom :: forall x. Trigender -> Rep Trigender x
Generic, Eq Trigender
Trigender -> Trigender -> Bool
Trigender -> Trigender -> Ordering
Trigender -> Trigender -> Trigender
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 :: Trigender -> Trigender -> Trigender
$cmin :: Trigender -> Trigender -> Trigender
max :: Trigender -> Trigender -> Trigender
$cmax :: Trigender -> Trigender -> Trigender
>= :: Trigender -> Trigender -> Bool
$c>= :: Trigender -> Trigender -> Bool
> :: Trigender -> Trigender -> Bool
$c> :: Trigender -> Trigender -> Bool
<= :: Trigender -> Trigender -> Bool
$c<= :: Trigender -> Trigender -> Bool
< :: Trigender -> Trigender -> Bool
$c< :: Trigender -> Trigender -> Bool
compare :: Trigender -> Trigender -> Ordering
$ccompare :: Trigender -> Trigender -> Ordering
Ord, ReadPrec [Trigender]
ReadPrec Trigender
Int -> ReadS Trigender
ReadS [Trigender]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Trigender]
$creadListPrec :: ReadPrec [Trigender]
readPrec :: ReadPrec Trigender
$creadPrec :: ReadPrec Trigender
readList :: ReadS [Trigender]
$creadList :: ReadS [Trigender]
readsPrec :: Int -> ReadS Trigender
$creadsPrec :: Int -> ReadS Trigender
Read, Int -> Trigender -> ShowS
[Trigender] -> ShowS
Trigender -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Trigender] -> ShowS
$cshowList :: [Trigender] -> ShowS
show :: Trigender -> [Char]
$cshow :: Trigender -> [Char]
showsPrec :: Int -> Trigender -> ShowS
$cshowsPrec :: Int -> Trigender -> ShowS
Show)

instance Bounded Trigender where
  minBound :: Trigender
minBound = BinaryGender -> Trigender
Binary forall a. Bounded a => a
minBound
  maxBound :: Trigender
maxBound = Trigender
Transgender

instance Enum Trigender where
  fromEnum :: Trigender -> Int
fromEnum (Binary BinaryGender
g) = forall a. Enum a => a -> Int
fromEnum BinaryGender
g
  fromEnum Trigender
Transgender = Int
2
  toEnum :: Int -> Trigender
toEnum Int
2 = Trigender
Transgender
  toEnum Int
x = BinaryGender -> Trigender
Binary (forall a. Enum a => Int -> a
toEnum Int
x)

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

instance Hashable Trigender

instance NFData Trigender

instance UnicodeText Trigender where
  toUnicodeText :: Trigender -> Text
toUnicodeText (Binary BinaryGender
g) = forall a. UnicodeText a => a -> Text
toUnicodeText BinaryGender
g
  toUnicodeText Trigender
Transgender = Text
"\x26a7\xfe0f"
  fromUnicodeText :: Text -> Maybe Trigender
fromUnicodeText Text
"\x26a7\xfe0f" = forall a. a -> Maybe a
Just Trigender
Transgender
  fromUnicodeText Text
x = BinaryGender -> Trigender
Binary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. UnicodeText a => Text -> Maybe a
fromUnicodeText Text
x
  isInTextRange :: Text -> Bool
isInTextRange Text
"\x26a7\xfe0f" = Bool
True
  isInTextRange Text
c = forall a. UnicodeText a => Text -> Bool
isInTextRange @BinaryGender Text
c