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

-- |
-- Module      : Data.Char.Emoji.NoEvilMonkey
-- Description : Support for the /no-evil monkeys in the Unicode standard.
-- Maintainer  : hapytexeu+gh@gmail.com
-- Stability   : experimental
-- Portability : POSIX
--
-- Unicode has three codepoints that refer to characters of monkeys where the first one does not see, the second does not hear, and the third one does not speak.
module Data.Char.Emoji.NoEvilMonkey
  ( NoEvilMonkey (SeeNoEvilMonkey, HearNoEvilMonkey, SpeakNoEvilMonkey),
  )
where

import Control.DeepSeq (NFData)
import Data.Char.Core (UnicodeCharacter (fromUnicodeChar, fromUnicodeChar', isInCharRange, toUnicodeChar), UnicodeText (isInTextRange), generateIsInTextRange', mapFromEnum, mapToEnum, mapToEnumSafe)
import Data.Data (Data)
import Data.Hashable (Hashable)
import GHC.Generics (Generic)
import Test.QuickCheck.Arbitrary (Arbitrary (arbitrary), arbitraryBoundedEnum)

_noEvilMonkeyOffset :: Int
_noEvilMonkeyOffset :: Int
_noEvilMonkeyOffset = Int
0x1f648

-- | A data constructors that lists the three different /no-evil/ monkeys.
data NoEvilMonkey
  = -- | The /see-no-evil monkey/, denoted with 🙈.
    SeeNoEvilMonkey
  | -- | The /hear-no-evil monkey/, denoted with 🙉.
    HearNoEvilMonkey
  | -- | The /speak-no-evil monkey/, denoted with 🙊.
    SpeakNoEvilMonkey
  deriving (NoEvilMonkey
forall a. a -> a -> Bounded a
maxBound :: NoEvilMonkey
$cmaxBound :: NoEvilMonkey
minBound :: NoEvilMonkey
$cminBound :: NoEvilMonkey
Bounded, Typeable NoEvilMonkey
NoEvilMonkey -> DataType
NoEvilMonkey -> Constr
(forall b. Data b => b -> b) -> NoEvilMonkey -> NoEvilMonkey
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) -> NoEvilMonkey -> u
forall u. (forall d. Data d => d -> u) -> NoEvilMonkey -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NoEvilMonkey -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NoEvilMonkey -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NoEvilMonkey -> m NoEvilMonkey
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NoEvilMonkey -> m NoEvilMonkey
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NoEvilMonkey
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NoEvilMonkey -> c NoEvilMonkey
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NoEvilMonkey)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NoEvilMonkey)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NoEvilMonkey -> m NoEvilMonkey
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NoEvilMonkey -> m NoEvilMonkey
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NoEvilMonkey -> m NoEvilMonkey
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NoEvilMonkey -> m NoEvilMonkey
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NoEvilMonkey -> m NoEvilMonkey
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NoEvilMonkey -> m NoEvilMonkey
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NoEvilMonkey -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NoEvilMonkey -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> NoEvilMonkey -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NoEvilMonkey -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NoEvilMonkey -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NoEvilMonkey -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NoEvilMonkey -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NoEvilMonkey -> r
gmapT :: (forall b. Data b => b -> b) -> NoEvilMonkey -> NoEvilMonkey
$cgmapT :: (forall b. Data b => b -> b) -> NoEvilMonkey -> NoEvilMonkey
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NoEvilMonkey)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NoEvilMonkey)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NoEvilMonkey)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NoEvilMonkey)
dataTypeOf :: NoEvilMonkey -> DataType
$cdataTypeOf :: NoEvilMonkey -> DataType
toConstr :: NoEvilMonkey -> Constr
$ctoConstr :: NoEvilMonkey -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NoEvilMonkey
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NoEvilMonkey
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NoEvilMonkey -> c NoEvilMonkey
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NoEvilMonkey -> c NoEvilMonkey
Data, Int -> NoEvilMonkey
NoEvilMonkey -> Int
NoEvilMonkey -> [NoEvilMonkey]
NoEvilMonkey -> NoEvilMonkey
NoEvilMonkey -> NoEvilMonkey -> [NoEvilMonkey]
NoEvilMonkey -> NoEvilMonkey -> NoEvilMonkey -> [NoEvilMonkey]
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 :: NoEvilMonkey -> NoEvilMonkey -> NoEvilMonkey -> [NoEvilMonkey]
$cenumFromThenTo :: NoEvilMonkey -> NoEvilMonkey -> NoEvilMonkey -> [NoEvilMonkey]
enumFromTo :: NoEvilMonkey -> NoEvilMonkey -> [NoEvilMonkey]
$cenumFromTo :: NoEvilMonkey -> NoEvilMonkey -> [NoEvilMonkey]
enumFromThen :: NoEvilMonkey -> NoEvilMonkey -> [NoEvilMonkey]
$cenumFromThen :: NoEvilMonkey -> NoEvilMonkey -> [NoEvilMonkey]
enumFrom :: NoEvilMonkey -> [NoEvilMonkey]
$cenumFrom :: NoEvilMonkey -> [NoEvilMonkey]
fromEnum :: NoEvilMonkey -> Int
$cfromEnum :: NoEvilMonkey -> Int
toEnum :: Int -> NoEvilMonkey
$ctoEnum :: Int -> NoEvilMonkey
pred :: NoEvilMonkey -> NoEvilMonkey
$cpred :: NoEvilMonkey -> NoEvilMonkey
succ :: NoEvilMonkey -> NoEvilMonkey
$csucc :: NoEvilMonkey -> NoEvilMonkey
Enum, NoEvilMonkey -> NoEvilMonkey -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NoEvilMonkey -> NoEvilMonkey -> Bool
$c/= :: NoEvilMonkey -> NoEvilMonkey -> Bool
== :: NoEvilMonkey -> NoEvilMonkey -> Bool
$c== :: NoEvilMonkey -> NoEvilMonkey -> Bool
Eq, forall x. Rep NoEvilMonkey x -> NoEvilMonkey
forall x. NoEvilMonkey -> Rep NoEvilMonkey x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NoEvilMonkey x -> NoEvilMonkey
$cfrom :: forall x. NoEvilMonkey -> Rep NoEvilMonkey x
Generic, Eq NoEvilMonkey
NoEvilMonkey -> NoEvilMonkey -> Bool
NoEvilMonkey -> NoEvilMonkey -> Ordering
NoEvilMonkey -> NoEvilMonkey -> NoEvilMonkey
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 :: NoEvilMonkey -> NoEvilMonkey -> NoEvilMonkey
$cmin :: NoEvilMonkey -> NoEvilMonkey -> NoEvilMonkey
max :: NoEvilMonkey -> NoEvilMonkey -> NoEvilMonkey
$cmax :: NoEvilMonkey -> NoEvilMonkey -> NoEvilMonkey
>= :: NoEvilMonkey -> NoEvilMonkey -> Bool
$c>= :: NoEvilMonkey -> NoEvilMonkey -> Bool
> :: NoEvilMonkey -> NoEvilMonkey -> Bool
$c> :: NoEvilMonkey -> NoEvilMonkey -> Bool
<= :: NoEvilMonkey -> NoEvilMonkey -> Bool
$c<= :: NoEvilMonkey -> NoEvilMonkey -> Bool
< :: NoEvilMonkey -> NoEvilMonkey -> Bool
$c< :: NoEvilMonkey -> NoEvilMonkey -> Bool
compare :: NoEvilMonkey -> NoEvilMonkey -> Ordering
$ccompare :: NoEvilMonkey -> NoEvilMonkey -> Ordering
Ord, ReadPrec [NoEvilMonkey]
ReadPrec NoEvilMonkey
Int -> ReadS NoEvilMonkey
ReadS [NoEvilMonkey]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NoEvilMonkey]
$creadListPrec :: ReadPrec [NoEvilMonkey]
readPrec :: ReadPrec NoEvilMonkey
$creadPrec :: ReadPrec NoEvilMonkey
readList :: ReadS [NoEvilMonkey]
$creadList :: ReadS [NoEvilMonkey]
readsPrec :: Int -> ReadS NoEvilMonkey
$creadsPrec :: Int -> ReadS NoEvilMonkey
Read, Int -> NoEvilMonkey -> ShowS
[NoEvilMonkey] -> ShowS
NoEvilMonkey -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NoEvilMonkey] -> ShowS
$cshowList :: [NoEvilMonkey] -> ShowS
show :: NoEvilMonkey -> String
$cshow :: NoEvilMonkey -> String
showsPrec :: Int -> NoEvilMonkey -> ShowS
$cshowsPrec :: Int -> NoEvilMonkey -> ShowS
Show)

instance Hashable NoEvilMonkey

instance NFData NoEvilMonkey

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

instance UnicodeCharacter NoEvilMonkey where
  toUnicodeChar :: NoEvilMonkey -> Char
toUnicodeChar = forall a. Enum a => Int -> a -> Char
mapFromEnum Int
_noEvilMonkeyOffset
  fromUnicodeChar :: Char -> Maybe NoEvilMonkey
fromUnicodeChar = forall a. (Bounded a, Enum a) => Int -> Char -> Maybe a
mapToEnumSafe Int
_noEvilMonkeyOffset
  fromUnicodeChar' :: Char -> NoEvilMonkey
fromUnicodeChar' = forall a. Enum a => Int -> Char -> a
mapToEnum Int
_noEvilMonkeyOffset
  isInCharRange :: Char -> Bool
isInCharRange Char
c = Char
'\x1f648' forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c forall a. Ord a => a -> a -> Bool
<= Char
'\x1f64a'

instance UnicodeText NoEvilMonkey where
  isInTextRange :: Text -> Bool
isInTextRange = forall a. UnicodeCharacter a => Text -> Bool
generateIsInTextRange' @NoEvilMonkey