{-# LANGUAGE DeriveDataTypeable, DeriveGeneric, Safe, 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(toUnicodeChar, fromUnicodeChar, fromUnicodeChar', isInCharRange), 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
  = SeeNoEvilMonkey  -- ^ The /see-no-evil monkey/, denoted with 🙈.
  | HearNoEvilMonkey  -- ^ The /hear-no-evil monkey/, denoted with 🙉.
  | SpeakNoEvilMonkey  -- ^ The /speak-no-evil monkey/, denoted with 🙊.
  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