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

-- |
-- Module      : Data.Char.Card
-- Description : Support to work with card characters in unicode.
-- Maintainer  : hapytexeu+gh@gmail.com
-- Stability   : experimental
-- Portability : POSIX
--
-- The <https://www.unicode.org/charts/PDF/U1F0A0.pdf 1F0A0 code block> can be used to work with cards. This module makes working with the three sets of cards more convenient. The first set
-- are cards with a suit (four suits) and a rank (14 ranks), which allows us to generate 56 cards. Next there are three jokes with the colors /red/, /black/ and /white/. Finally
-- there are 21 trump cards and the fool card (a tarot card which normally has no number).
--
-- The module contains pattern synonyms that define common aliasses for these cards.
module Data.Char.Card
  ( -- * Data structures to define a card
    CardSuit (Spades, Hearts, Diamonds, Clubs),
    CardRank (Ace, R2, R3, R4, R5, R6, R7, R8, R9, R10, Jack, Knight, Queen, King),
    JokerColor (Red, Black, White),
    Trump
      ( Fool,
        Trump1,
        Trump2,
        Trump3,
        Trump4,
        Trump5,
        Trump6,
        Trump7,
        Trump8,
        Trump9,
        Trump10,
        Trump11,
        Trump12,
        Trump13,
        Trump14,
        Trump15,
        Trump16,
        Trump17,
        Trump18,
        Trump19,
        Trump20,
        Trump21
      ),
    Card (Back, Card, Joker, Trump),

    -- * Converting cards to the corresponding Unicode character
    back,
    card,
    card',
    joker,
    trump,

    -- * Pattern synonyms for cards

    -- ** Aliasses for the card suits
    pattern Swords,
    pattern Cups,
    pattern Pentacles,
    pattern Wands,

    -- ** Aliasses for the card ranks

    -- *** Aliasses for the jack
    pattern Valet,
    pattern Bube,
    pattern Unter,
    pattern Page,
    pattern Fante,

    -- *** Aliasses for the knight
    pattern Chevalier,
    pattern Ober,
    pattern Ritter,
    pattern Cavall,
    pattern Cavaliere,

    -- *** Aliasses for the queen
    pattern Dame,
    pattern Königin,
    pattern Regina,

    -- *** Aliasses for the king
    pattern Roi,
    pattern König,
    pattern Re,

    -- ** Trump patterns

    -- *** The four ages
    pattern Childhood,
    pattern Youth,
    pattern Maturity,
    pattern OldAge,

    -- *** The four times of the day
    pattern Morning,
    pattern Afternoon,
    pattern Evening,
    pattern Night,

    -- *** The four elements
    pattern Earth,
    pattern Air,
    pattern Water,
    pattern Fire,

    -- *** The four leisures
    pattern Dance,
    pattern Shopping,
    pattern OpenAir,
    pattern VisualArts,

    -- *** The four seasons
    pattern Spring,
    pattern Summer,
    pattern Autumn,
    pattern Winter,

    -- *** The game
    pattern Game,

    -- *** Folly
    pattern Collective,
    pattern Individual,
  )
where

import Control.DeepSeq (NFData)
import Data.Bits (shiftL, (.|.))
import Data.Char (chr)
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)
import Test.QuickCheck.Gen (oneof)

_suitOffset :: Int
_suitOffset :: Int
_suitOffset = Int
0x2660

-- | A data type for the card suits
data CardSuit
  = -- | The /spades/ card suit.
    Spades
  | -- | The /hearts/ card suit.
    Hearts
  | -- | The /diamonds/ card suit.
    Diamonds
  | -- | The /clubs/ card suit.
    Clubs
  deriving (CardSuit
CardSuit -> CardSuit -> Bounded CardSuit
forall a. a -> a -> Bounded a
$cminBound :: CardSuit
minBound :: CardSuit
$cmaxBound :: CardSuit
maxBound :: CardSuit
Bounded, Typeable CardSuit
Typeable CardSuit
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CardSuit -> c CardSuit)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CardSuit)
-> (CardSuit -> Constr)
-> (CardSuit -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CardSuit))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CardSuit))
-> ((forall b. Data b => b -> b) -> CardSuit -> CardSuit)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CardSuit -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CardSuit -> r)
-> (forall u. (forall d. Data d => d -> u) -> CardSuit -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CardSuit -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CardSuit -> m CardSuit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CardSuit -> m CardSuit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CardSuit -> m CardSuit)
-> Data CardSuit
CardSuit -> Constr
CardSuit -> DataType
(forall b. Data b => b -> b) -> CardSuit -> CardSuit
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) -> CardSuit -> u
forall u. (forall d. Data d => d -> u) -> CardSuit -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CardSuit -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CardSuit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CardSuit -> m CardSuit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CardSuit -> m CardSuit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CardSuit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CardSuit -> c CardSuit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CardSuit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CardSuit)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CardSuit -> c CardSuit
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CardSuit -> c CardSuit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CardSuit
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CardSuit
$ctoConstr :: CardSuit -> Constr
toConstr :: CardSuit -> Constr
$cdataTypeOf :: CardSuit -> DataType
dataTypeOf :: CardSuit -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CardSuit)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CardSuit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CardSuit)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CardSuit)
$cgmapT :: (forall b. Data b => b -> b) -> CardSuit -> CardSuit
gmapT :: (forall b. Data b => b -> b) -> CardSuit -> CardSuit
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CardSuit -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CardSuit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CardSuit -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CardSuit -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CardSuit -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CardSuit -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CardSuit -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CardSuit -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CardSuit -> m CardSuit
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CardSuit -> m CardSuit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CardSuit -> m CardSuit
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CardSuit -> m CardSuit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CardSuit -> m CardSuit
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CardSuit -> m CardSuit
Data, Int -> CardSuit
CardSuit -> Int
CardSuit -> [CardSuit]
CardSuit -> CardSuit
CardSuit -> CardSuit -> [CardSuit]
CardSuit -> CardSuit -> CardSuit -> [CardSuit]
(CardSuit -> CardSuit)
-> (CardSuit -> CardSuit)
-> (Int -> CardSuit)
-> (CardSuit -> Int)
-> (CardSuit -> [CardSuit])
-> (CardSuit -> CardSuit -> [CardSuit])
-> (CardSuit -> CardSuit -> [CardSuit])
-> (CardSuit -> CardSuit -> CardSuit -> [CardSuit])
-> Enum CardSuit
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: CardSuit -> CardSuit
succ :: CardSuit -> CardSuit
$cpred :: CardSuit -> CardSuit
pred :: CardSuit -> CardSuit
$ctoEnum :: Int -> CardSuit
toEnum :: Int -> CardSuit
$cfromEnum :: CardSuit -> Int
fromEnum :: CardSuit -> Int
$cenumFrom :: CardSuit -> [CardSuit]
enumFrom :: CardSuit -> [CardSuit]
$cenumFromThen :: CardSuit -> CardSuit -> [CardSuit]
enumFromThen :: CardSuit -> CardSuit -> [CardSuit]
$cenumFromTo :: CardSuit -> CardSuit -> [CardSuit]
enumFromTo :: CardSuit -> CardSuit -> [CardSuit]
$cenumFromThenTo :: CardSuit -> CardSuit -> CardSuit -> [CardSuit]
enumFromThenTo :: CardSuit -> CardSuit -> CardSuit -> [CardSuit]
Enum, CardSuit -> CardSuit -> Bool
(CardSuit -> CardSuit -> Bool)
-> (CardSuit -> CardSuit -> Bool) -> Eq CardSuit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CardSuit -> CardSuit -> Bool
== :: CardSuit -> CardSuit -> Bool
$c/= :: CardSuit -> CardSuit -> Bool
/= :: CardSuit -> CardSuit -> Bool
Eq, (forall x. CardSuit -> Rep CardSuit x)
-> (forall x. Rep CardSuit x -> CardSuit) -> Generic CardSuit
forall x. Rep CardSuit x -> CardSuit
forall x. CardSuit -> Rep CardSuit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CardSuit -> Rep CardSuit x
from :: forall x. CardSuit -> Rep CardSuit x
$cto :: forall x. Rep CardSuit x -> CardSuit
to :: forall x. Rep CardSuit x -> CardSuit
Generic, Eq CardSuit
Eq CardSuit
-> (CardSuit -> CardSuit -> Ordering)
-> (CardSuit -> CardSuit -> Bool)
-> (CardSuit -> CardSuit -> Bool)
-> (CardSuit -> CardSuit -> Bool)
-> (CardSuit -> CardSuit -> Bool)
-> (CardSuit -> CardSuit -> CardSuit)
-> (CardSuit -> CardSuit -> CardSuit)
-> Ord CardSuit
CardSuit -> CardSuit -> Bool
CardSuit -> CardSuit -> Ordering
CardSuit -> CardSuit -> CardSuit
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
$ccompare :: CardSuit -> CardSuit -> Ordering
compare :: CardSuit -> CardSuit -> Ordering
$c< :: CardSuit -> CardSuit -> Bool
< :: CardSuit -> CardSuit -> Bool
$c<= :: CardSuit -> CardSuit -> Bool
<= :: CardSuit -> CardSuit -> Bool
$c> :: CardSuit -> CardSuit -> Bool
> :: CardSuit -> CardSuit -> Bool
$c>= :: CardSuit -> CardSuit -> Bool
>= :: CardSuit -> CardSuit -> Bool
$cmax :: CardSuit -> CardSuit -> CardSuit
max :: CardSuit -> CardSuit -> CardSuit
$cmin :: CardSuit -> CardSuit -> CardSuit
min :: CardSuit -> CardSuit -> CardSuit
Ord, ReadPrec [CardSuit]
ReadPrec CardSuit
Int -> ReadS CardSuit
ReadS [CardSuit]
(Int -> ReadS CardSuit)
-> ReadS [CardSuit]
-> ReadPrec CardSuit
-> ReadPrec [CardSuit]
-> Read CardSuit
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CardSuit
readsPrec :: Int -> ReadS CardSuit
$creadList :: ReadS [CardSuit]
readList :: ReadS [CardSuit]
$creadPrec :: ReadPrec CardSuit
readPrec :: ReadPrec CardSuit
$creadListPrec :: ReadPrec [CardSuit]
readListPrec :: ReadPrec [CardSuit]
Read, Int -> CardSuit -> ShowS
[CardSuit] -> ShowS
CardSuit -> String
(Int -> CardSuit -> ShowS)
-> (CardSuit -> String) -> ([CardSuit] -> ShowS) -> Show CardSuit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CardSuit -> ShowS
showsPrec :: Int -> CardSuit -> ShowS
$cshow :: CardSuit -> String
show :: CardSuit -> String
$cshowList :: [CardSuit] -> ShowS
showList :: [CardSuit] -> ShowS
Show)

instance Hashable CardSuit

instance NFData CardSuit

-- | A data type for the rank of the card.
data CardRank
  = -- | The /ace/ card rank.
    Ace
  | -- | Card rank 2.
    R2
  | -- | Card rank 3.
    R3
  | -- | Card rank 4.
    R4
  | -- | Card rank 5.
    R5
  | -- | Card rank 6.
    R6
  | -- | Card rank 7.
    R7
  | -- | Card rank 8.
    R8
  | -- | Card rank 9.
    R9
  | -- | Card rank 10.
    R10
  | -- | The /jack/ card rank.
    Jack
  | -- | The /knight/ card rank.
    Knight
  | -- | The /queen/ card rank.
    Queen
  | -- | The /king/ card rank.
    King
  deriving (CardRank
CardRank -> CardRank -> Bounded CardRank
forall a. a -> a -> Bounded a
$cminBound :: CardRank
minBound :: CardRank
$cmaxBound :: CardRank
maxBound :: CardRank
Bounded, Typeable CardRank
Typeable CardRank
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CardRank -> c CardRank)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CardRank)
-> (CardRank -> Constr)
-> (CardRank -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CardRank))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CardRank))
-> ((forall b. Data b => b -> b) -> CardRank -> CardRank)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CardRank -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CardRank -> r)
-> (forall u. (forall d. Data d => d -> u) -> CardRank -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CardRank -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CardRank -> m CardRank)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CardRank -> m CardRank)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CardRank -> m CardRank)
-> Data CardRank
CardRank -> Constr
CardRank -> DataType
(forall b. Data b => b -> b) -> CardRank -> CardRank
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) -> CardRank -> u
forall u. (forall d. Data d => d -> u) -> CardRank -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CardRank -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CardRank -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CardRank -> m CardRank
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CardRank -> m CardRank
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CardRank
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CardRank -> c CardRank
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CardRank)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CardRank)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CardRank -> c CardRank
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CardRank -> c CardRank
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CardRank
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CardRank
$ctoConstr :: CardRank -> Constr
toConstr :: CardRank -> Constr
$cdataTypeOf :: CardRank -> DataType
dataTypeOf :: CardRank -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CardRank)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CardRank)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CardRank)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CardRank)
$cgmapT :: (forall b. Data b => b -> b) -> CardRank -> CardRank
gmapT :: (forall b. Data b => b -> b) -> CardRank -> CardRank
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CardRank -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CardRank -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CardRank -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CardRank -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CardRank -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CardRank -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CardRank -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CardRank -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CardRank -> m CardRank
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CardRank -> m CardRank
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CardRank -> m CardRank
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CardRank -> m CardRank
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CardRank -> m CardRank
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CardRank -> m CardRank
Data, Int -> CardRank
CardRank -> Int
CardRank -> [CardRank]
CardRank -> CardRank
CardRank -> CardRank -> [CardRank]
CardRank -> CardRank -> CardRank -> [CardRank]
(CardRank -> CardRank)
-> (CardRank -> CardRank)
-> (Int -> CardRank)
-> (CardRank -> Int)
-> (CardRank -> [CardRank])
-> (CardRank -> CardRank -> [CardRank])
-> (CardRank -> CardRank -> [CardRank])
-> (CardRank -> CardRank -> CardRank -> [CardRank])
-> Enum CardRank
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: CardRank -> CardRank
succ :: CardRank -> CardRank
$cpred :: CardRank -> CardRank
pred :: CardRank -> CardRank
$ctoEnum :: Int -> CardRank
toEnum :: Int -> CardRank
$cfromEnum :: CardRank -> Int
fromEnum :: CardRank -> Int
$cenumFrom :: CardRank -> [CardRank]
enumFrom :: CardRank -> [CardRank]
$cenumFromThen :: CardRank -> CardRank -> [CardRank]
enumFromThen :: CardRank -> CardRank -> [CardRank]
$cenumFromTo :: CardRank -> CardRank -> [CardRank]
enumFromTo :: CardRank -> CardRank -> [CardRank]
$cenumFromThenTo :: CardRank -> CardRank -> CardRank -> [CardRank]
enumFromThenTo :: CardRank -> CardRank -> CardRank -> [CardRank]
Enum, CardRank -> CardRank -> Bool
(CardRank -> CardRank -> Bool)
-> (CardRank -> CardRank -> Bool) -> Eq CardRank
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CardRank -> CardRank -> Bool
== :: CardRank -> CardRank -> Bool
$c/= :: CardRank -> CardRank -> Bool
/= :: CardRank -> CardRank -> Bool
Eq, (forall x. CardRank -> Rep CardRank x)
-> (forall x. Rep CardRank x -> CardRank) -> Generic CardRank
forall x. Rep CardRank x -> CardRank
forall x. CardRank -> Rep CardRank x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CardRank -> Rep CardRank x
from :: forall x. CardRank -> Rep CardRank x
$cto :: forall x. Rep CardRank x -> CardRank
to :: forall x. Rep CardRank x -> CardRank
Generic, Eq CardRank
Eq CardRank
-> (CardRank -> CardRank -> Ordering)
-> (CardRank -> CardRank -> Bool)
-> (CardRank -> CardRank -> Bool)
-> (CardRank -> CardRank -> Bool)
-> (CardRank -> CardRank -> Bool)
-> (CardRank -> CardRank -> CardRank)
-> (CardRank -> CardRank -> CardRank)
-> Ord CardRank
CardRank -> CardRank -> Bool
CardRank -> CardRank -> Ordering
CardRank -> CardRank -> CardRank
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
$ccompare :: CardRank -> CardRank -> Ordering
compare :: CardRank -> CardRank -> Ordering
$c< :: CardRank -> CardRank -> Bool
< :: CardRank -> CardRank -> Bool
$c<= :: CardRank -> CardRank -> Bool
<= :: CardRank -> CardRank -> Bool
$c> :: CardRank -> CardRank -> Bool
> :: CardRank -> CardRank -> Bool
$c>= :: CardRank -> CardRank -> Bool
>= :: CardRank -> CardRank -> Bool
$cmax :: CardRank -> CardRank -> CardRank
max :: CardRank -> CardRank -> CardRank
$cmin :: CardRank -> CardRank -> CardRank
min :: CardRank -> CardRank -> CardRank
Ord, ReadPrec [CardRank]
ReadPrec CardRank
Int -> ReadS CardRank
ReadS [CardRank]
(Int -> ReadS CardRank)
-> ReadS [CardRank]
-> ReadPrec CardRank
-> ReadPrec [CardRank]
-> Read CardRank
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CardRank
readsPrec :: Int -> ReadS CardRank
$creadList :: ReadS [CardRank]
readList :: ReadS [CardRank]
$creadPrec :: ReadPrec CardRank
readPrec :: ReadPrec CardRank
$creadListPrec :: ReadPrec [CardRank]
readListPrec :: ReadPrec [CardRank]
Read, Int -> CardRank -> ShowS
[CardRank] -> ShowS
CardRank -> String
(Int -> CardRank -> ShowS)
-> (CardRank -> String) -> ([CardRank] -> ShowS) -> Show CardRank
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CardRank -> ShowS
showsPrec :: Int -> CardRank -> ShowS
$cshow :: CardRank -> String
show :: CardRank -> String
$cshowList :: [CardRank] -> ShowS
showList :: [CardRank] -> ShowS
Show)

instance Hashable CardRank

instance NFData CardRank

-- | A data type to represent the three colors for which there are jokers:
-- /red/, /black/ and /white/.
data JokerColor
  = -- | The /red/ joker.
    Red
  | -- | The /black/ joker.
    Black
  | -- | The /white/ joker.
    White
  deriving (JokerColor
JokerColor -> JokerColor -> Bounded JokerColor
forall a. a -> a -> Bounded a
$cminBound :: JokerColor
minBound :: JokerColor
$cmaxBound :: JokerColor
maxBound :: JokerColor
Bounded, Typeable JokerColor
Typeable JokerColor
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> JokerColor -> c JokerColor)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c JokerColor)
-> (JokerColor -> Constr)
-> (JokerColor -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c JokerColor))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c JokerColor))
-> ((forall b. Data b => b -> b) -> JokerColor -> JokerColor)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> JokerColor -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> JokerColor -> r)
-> (forall u. (forall d. Data d => d -> u) -> JokerColor -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> JokerColor -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> JokerColor -> m JokerColor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> JokerColor -> m JokerColor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> JokerColor -> m JokerColor)
-> Data JokerColor
JokerColor -> Constr
JokerColor -> DataType
(forall b. Data b => b -> b) -> JokerColor -> JokerColor
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) -> JokerColor -> u
forall u. (forall d. Data d => d -> u) -> JokerColor -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JokerColor -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JokerColor -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> JokerColor -> m JokerColor
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JokerColor -> m JokerColor
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JokerColor
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JokerColor -> c JokerColor
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JokerColor)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JokerColor)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JokerColor -> c JokerColor
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JokerColor -> c JokerColor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JokerColor
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JokerColor
$ctoConstr :: JokerColor -> Constr
toConstr :: JokerColor -> Constr
$cdataTypeOf :: JokerColor -> DataType
dataTypeOf :: JokerColor -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JokerColor)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JokerColor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JokerColor)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JokerColor)
$cgmapT :: (forall b. Data b => b -> b) -> JokerColor -> JokerColor
gmapT :: (forall b. Data b => b -> b) -> JokerColor -> JokerColor
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JokerColor -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JokerColor -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JokerColor -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JokerColor -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> JokerColor -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> JokerColor -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> JokerColor -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> JokerColor -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> JokerColor -> m JokerColor
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> JokerColor -> m JokerColor
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JokerColor -> m JokerColor
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JokerColor -> m JokerColor
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JokerColor -> m JokerColor
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JokerColor -> m JokerColor
Data, Int -> JokerColor
JokerColor -> Int
JokerColor -> [JokerColor]
JokerColor -> JokerColor
JokerColor -> JokerColor -> [JokerColor]
JokerColor -> JokerColor -> JokerColor -> [JokerColor]
(JokerColor -> JokerColor)
-> (JokerColor -> JokerColor)
-> (Int -> JokerColor)
-> (JokerColor -> Int)
-> (JokerColor -> [JokerColor])
-> (JokerColor -> JokerColor -> [JokerColor])
-> (JokerColor -> JokerColor -> [JokerColor])
-> (JokerColor -> JokerColor -> JokerColor -> [JokerColor])
-> Enum JokerColor
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: JokerColor -> JokerColor
succ :: JokerColor -> JokerColor
$cpred :: JokerColor -> JokerColor
pred :: JokerColor -> JokerColor
$ctoEnum :: Int -> JokerColor
toEnum :: Int -> JokerColor
$cfromEnum :: JokerColor -> Int
fromEnum :: JokerColor -> Int
$cenumFrom :: JokerColor -> [JokerColor]
enumFrom :: JokerColor -> [JokerColor]
$cenumFromThen :: JokerColor -> JokerColor -> [JokerColor]
enumFromThen :: JokerColor -> JokerColor -> [JokerColor]
$cenumFromTo :: JokerColor -> JokerColor -> [JokerColor]
enumFromTo :: JokerColor -> JokerColor -> [JokerColor]
$cenumFromThenTo :: JokerColor -> JokerColor -> JokerColor -> [JokerColor]
enumFromThenTo :: JokerColor -> JokerColor -> JokerColor -> [JokerColor]
Enum, JokerColor -> JokerColor -> Bool
(JokerColor -> JokerColor -> Bool)
-> (JokerColor -> JokerColor -> Bool) -> Eq JokerColor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JokerColor -> JokerColor -> Bool
== :: JokerColor -> JokerColor -> Bool
$c/= :: JokerColor -> JokerColor -> Bool
/= :: JokerColor -> JokerColor -> Bool
Eq, (forall x. JokerColor -> Rep JokerColor x)
-> (forall x. Rep JokerColor x -> JokerColor) -> Generic JokerColor
forall x. Rep JokerColor x -> JokerColor
forall x. JokerColor -> Rep JokerColor x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JokerColor -> Rep JokerColor x
from :: forall x. JokerColor -> Rep JokerColor x
$cto :: forall x. Rep JokerColor x -> JokerColor
to :: forall x. Rep JokerColor x -> JokerColor
Generic, Eq JokerColor
Eq JokerColor
-> (JokerColor -> JokerColor -> Ordering)
-> (JokerColor -> JokerColor -> Bool)
-> (JokerColor -> JokerColor -> Bool)
-> (JokerColor -> JokerColor -> Bool)
-> (JokerColor -> JokerColor -> Bool)
-> (JokerColor -> JokerColor -> JokerColor)
-> (JokerColor -> JokerColor -> JokerColor)
-> Ord JokerColor
JokerColor -> JokerColor -> Bool
JokerColor -> JokerColor -> Ordering
JokerColor -> JokerColor -> JokerColor
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
$ccompare :: JokerColor -> JokerColor -> Ordering
compare :: JokerColor -> JokerColor -> Ordering
$c< :: JokerColor -> JokerColor -> Bool
< :: JokerColor -> JokerColor -> Bool
$c<= :: JokerColor -> JokerColor -> Bool
<= :: JokerColor -> JokerColor -> Bool
$c> :: JokerColor -> JokerColor -> Bool
> :: JokerColor -> JokerColor -> Bool
$c>= :: JokerColor -> JokerColor -> Bool
>= :: JokerColor -> JokerColor -> Bool
$cmax :: JokerColor -> JokerColor -> JokerColor
max :: JokerColor -> JokerColor -> JokerColor
$cmin :: JokerColor -> JokerColor -> JokerColor
min :: JokerColor -> JokerColor -> JokerColor
Ord, ReadPrec [JokerColor]
ReadPrec JokerColor
Int -> ReadS JokerColor
ReadS [JokerColor]
(Int -> ReadS JokerColor)
-> ReadS [JokerColor]
-> ReadPrec JokerColor
-> ReadPrec [JokerColor]
-> Read JokerColor
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS JokerColor
readsPrec :: Int -> ReadS JokerColor
$creadList :: ReadS [JokerColor]
readList :: ReadS [JokerColor]
$creadPrec :: ReadPrec JokerColor
readPrec :: ReadPrec JokerColor
$creadListPrec :: ReadPrec [JokerColor]
readListPrec :: ReadPrec [JokerColor]
Read, Int -> JokerColor -> ShowS
[JokerColor] -> ShowS
JokerColor -> String
(Int -> JokerColor -> ShowS)
-> (JokerColor -> String)
-> ([JokerColor] -> ShowS)
-> Show JokerColor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JokerColor -> ShowS
showsPrec :: Int -> JokerColor -> ShowS
$cshow :: JokerColor -> String
show :: JokerColor -> String
$cshowList :: [JokerColor] -> ShowS
showList :: [JokerColor] -> ShowS
Show)

instance Hashable JokerColor

instance NFData JokerColor

-- | A data type for the trump cards, often used for /tarot/.
data Trump
  = -- | The /fool/ trump card, this tarot card is normally not numbered.
    Fool
  | -- | Tarot card /I/.
    Trump1
  | -- | Tarot card /II/.
    Trump2
  | -- | Tarot card /III/.
    Trump3
  | -- | Tarot card /IV/.
    Trump4
  | -- | Tarot card /V/.
    Trump5
  | -- | Tarot card /VI/.
    Trump6
  | -- | Tarot card /VII/.
    Trump7
  | -- | Tarot card /VIII/.
    Trump8
  | -- | Tarot card /IX/.
    Trump9
  | -- | Tarot card /X/.
    Trump10
  | -- | Tarot card /XI/.
    Trump11
  | -- | Tarot card /XII/.
    Trump12
  | -- | Tarot card /XIII/.
    Trump13
  | -- | Tarot card /XIV/.
    Trump14
  | -- | Tarot card /XV/.
    Trump15
  | -- | Tarot card /XVI/.
    Trump16
  | -- | Tarot card /XVII/.
    Trump17
  | -- | Tarot card /XVIII/.
    Trump18
  | -- | Tarot card /XIX/.
    Trump19
  | -- | Tarot card /XX/.
    Trump20
  | -- | Tarot card /XXI/.
    Trump21
  deriving (Trump
Trump -> Trump -> Bounded Trump
forall a. a -> a -> Bounded a
$cminBound :: Trump
minBound :: Trump
$cmaxBound :: Trump
maxBound :: Trump
Bounded, Typeable Trump
Typeable Trump
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Trump -> c Trump)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Trump)
-> (Trump -> Constr)
-> (Trump -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Trump))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Trump))
-> ((forall b. Data b => b -> b) -> Trump -> Trump)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Trump -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Trump -> r)
-> (forall u. (forall d. Data d => d -> u) -> Trump -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Trump -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Trump -> m Trump)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Trump -> m Trump)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Trump -> m Trump)
-> Data Trump
Trump -> Constr
Trump -> DataType
(forall b. Data b => b -> b) -> Trump -> Trump
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) -> Trump -> u
forall u. (forall d. Data d => d -> u) -> Trump -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Trump -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Trump -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Trump -> m Trump
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Trump -> m Trump
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Trump
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Trump -> c Trump
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Trump)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Trump)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Trump -> c Trump
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Trump -> c Trump
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Trump
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Trump
$ctoConstr :: Trump -> Constr
toConstr :: Trump -> Constr
$cdataTypeOf :: Trump -> DataType
dataTypeOf :: Trump -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Trump)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Trump)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Trump)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Trump)
$cgmapT :: (forall b. Data b => b -> b) -> Trump -> Trump
gmapT :: (forall b. Data b => b -> b) -> Trump -> Trump
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Trump -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Trump -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Trump -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Trump -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Trump -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Trump -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Trump -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Trump -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Trump -> m Trump
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Trump -> m Trump
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Trump -> m Trump
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Trump -> m Trump
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Trump -> m Trump
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Trump -> m Trump
Data, Int -> Trump
Trump -> Int
Trump -> [Trump]
Trump -> Trump
Trump -> Trump -> [Trump]
Trump -> Trump -> Trump -> [Trump]
(Trump -> Trump)
-> (Trump -> Trump)
-> (Int -> Trump)
-> (Trump -> Int)
-> (Trump -> [Trump])
-> (Trump -> Trump -> [Trump])
-> (Trump -> Trump -> [Trump])
-> (Trump -> Trump -> Trump -> [Trump])
-> Enum Trump
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Trump -> Trump
succ :: Trump -> Trump
$cpred :: Trump -> Trump
pred :: Trump -> Trump
$ctoEnum :: Int -> Trump
toEnum :: Int -> Trump
$cfromEnum :: Trump -> Int
fromEnum :: Trump -> Int
$cenumFrom :: Trump -> [Trump]
enumFrom :: Trump -> [Trump]
$cenumFromThen :: Trump -> Trump -> [Trump]
enumFromThen :: Trump -> Trump -> [Trump]
$cenumFromTo :: Trump -> Trump -> [Trump]
enumFromTo :: Trump -> Trump -> [Trump]
$cenumFromThenTo :: Trump -> Trump -> Trump -> [Trump]
enumFromThenTo :: Trump -> Trump -> Trump -> [Trump]
Enum, Trump -> Trump -> Bool
(Trump -> Trump -> Bool) -> (Trump -> Trump -> Bool) -> Eq Trump
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Trump -> Trump -> Bool
== :: Trump -> Trump -> Bool
$c/= :: Trump -> Trump -> Bool
/= :: Trump -> Trump -> Bool
Eq, (forall x. Trump -> Rep Trump x)
-> (forall x. Rep Trump x -> Trump) -> Generic Trump
forall x. Rep Trump x -> Trump
forall x. Trump -> Rep Trump x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Trump -> Rep Trump x
from :: forall x. Trump -> Rep Trump x
$cto :: forall x. Rep Trump x -> Trump
to :: forall x. Rep Trump x -> Trump
Generic, Eq Trump
Eq Trump
-> (Trump -> Trump -> Ordering)
-> (Trump -> Trump -> Bool)
-> (Trump -> Trump -> Bool)
-> (Trump -> Trump -> Bool)
-> (Trump -> Trump -> Bool)
-> (Trump -> Trump -> Trump)
-> (Trump -> Trump -> Trump)
-> Ord Trump
Trump -> Trump -> Bool
Trump -> Trump -> Ordering
Trump -> Trump -> Trump
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
$ccompare :: Trump -> Trump -> Ordering
compare :: Trump -> Trump -> Ordering
$c< :: Trump -> Trump -> Bool
< :: Trump -> Trump -> Bool
$c<= :: Trump -> Trump -> Bool
<= :: Trump -> Trump -> Bool
$c> :: Trump -> Trump -> Bool
> :: Trump -> Trump -> Bool
$c>= :: Trump -> Trump -> Bool
>= :: Trump -> Trump -> Bool
$cmax :: Trump -> Trump -> Trump
max :: Trump -> Trump -> Trump
$cmin :: Trump -> Trump -> Trump
min :: Trump -> Trump -> Trump
Ord, ReadPrec [Trump]
ReadPrec Trump
Int -> ReadS Trump
ReadS [Trump]
(Int -> ReadS Trump)
-> ReadS [Trump]
-> ReadPrec Trump
-> ReadPrec [Trump]
-> Read Trump
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Trump
readsPrec :: Int -> ReadS Trump
$creadList :: ReadS [Trump]
readList :: ReadS [Trump]
$creadPrec :: ReadPrec Trump
readPrec :: ReadPrec Trump
$creadListPrec :: ReadPrec [Trump]
readListPrec :: ReadPrec [Trump]
Read, Int -> Trump -> ShowS
[Trump] -> ShowS
Trump -> String
(Int -> Trump -> ShowS)
-> (Trump -> String) -> ([Trump] -> ShowS) -> Show Trump
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Trump -> ShowS
showsPrec :: Int -> Trump -> ShowS
$cshow :: Trump -> String
show :: Trump -> String
$cshowList :: [Trump] -> ShowS
showList :: [Trump] -> ShowS
Show)

instance Hashable Trump

instance NFData Trump

-- | A data type that represents the possible types of cards for which there is
-- a Unicode characters. This is the back of a card, a card with a suit and
-- rank, three /jokers/, and the 21 /trump/ cards and the /fool/.
data Card
  = -- | The back of the card.
    Back
  | -- | A card that is a combination of a 'CardSuit' and a 'CardRank'. There are 56 possibilities.
    Card CardSuit CardRank
  | -- | Three possible 'JokerColor' cards.
    Joker JokerColor
  | Trump Trump -- The 21 't:Trump' cards (together with the 'Fool', which is usually not numbered).
  deriving (Typeable Card
Typeable Card
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Card -> c Card)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Card)
-> (Card -> Constr)
-> (Card -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Card))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Card))
-> ((forall b. Data b => b -> b) -> Card -> Card)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Card -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Card -> r)
-> (forall u. (forall d. Data d => d -> u) -> Card -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Card -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Card -> m Card)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Card -> m Card)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Card -> m Card)
-> Data Card
Card -> Constr
Card -> DataType
(forall b. Data b => b -> b) -> Card -> Card
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) -> Card -> u
forall u. (forall d. Data d => d -> u) -> Card -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Card -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Card -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Card -> m Card
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Card -> m Card
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Card
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Card -> c Card
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Card)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Card)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Card -> c Card
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Card -> c Card
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Card
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Card
$ctoConstr :: Card -> Constr
toConstr :: Card -> Constr
$cdataTypeOf :: Card -> DataType
dataTypeOf :: Card -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Card)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Card)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Card)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Card)
$cgmapT :: (forall b. Data b => b -> b) -> Card -> Card
gmapT :: (forall b. Data b => b -> b) -> Card -> Card
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Card -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Card -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Card -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Card -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Card -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Card -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Card -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Card -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Card -> m Card
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Card -> m Card
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Card -> m Card
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Card -> m Card
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Card -> m Card
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Card -> m Card
Data, Card -> Card -> Bool
(Card -> Card -> Bool) -> (Card -> Card -> Bool) -> Eq Card
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Card -> Card -> Bool
== :: Card -> Card -> Bool
$c/= :: Card -> Card -> Bool
/= :: Card -> Card -> Bool
Eq, (forall x. Card -> Rep Card x)
-> (forall x. Rep Card x -> Card) -> Generic Card
forall x. Rep Card x -> Card
forall x. Card -> Rep Card x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Card -> Rep Card x
from :: forall x. Card -> Rep Card x
$cto :: forall x. Rep Card x -> Card
to :: forall x. Rep Card x -> Card
Generic, Eq Card
Eq Card
-> (Card -> Card -> Ordering)
-> (Card -> Card -> Bool)
-> (Card -> Card -> Bool)
-> (Card -> Card -> Bool)
-> (Card -> Card -> Bool)
-> (Card -> Card -> Card)
-> (Card -> Card -> Card)
-> Ord Card
Card -> Card -> Bool
Card -> Card -> Ordering
Card -> Card -> Card
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
$ccompare :: Card -> Card -> Ordering
compare :: Card -> Card -> Ordering
$c< :: Card -> Card -> Bool
< :: Card -> Card -> Bool
$c<= :: Card -> Card -> Bool
<= :: Card -> Card -> Bool
$c> :: Card -> Card -> Bool
> :: Card -> Card -> Bool
$c>= :: Card -> Card -> Bool
>= :: Card -> Card -> Bool
$cmax :: Card -> Card -> Card
max :: Card -> Card -> Card
$cmin :: Card -> Card -> Card
min :: Card -> Card -> Card
Ord, ReadPrec [Card]
ReadPrec Card
Int -> ReadS Card
ReadS [Card]
(Int -> ReadS Card)
-> ReadS [Card] -> ReadPrec Card -> ReadPrec [Card] -> Read Card
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Card
readsPrec :: Int -> ReadS Card
$creadList :: ReadS [Card]
readList :: ReadS [Card]
$creadPrec :: ReadPrec Card
readPrec :: ReadPrec Card
$creadListPrec :: ReadPrec [Card]
readListPrec :: ReadPrec [Card]
Read, Int -> Card -> ShowS
[Card] -> ShowS
Card -> String
(Int -> Card -> ShowS)
-> (Card -> String) -> ([Card] -> ShowS) -> Show Card
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Card -> ShowS
showsPrec :: Int -> Card -> ShowS
$cshow :: Card -> String
show :: Card -> String
$cshowList :: [Card] -> ShowS
showList :: [Card] -> ShowS
Show)

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

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

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

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

instance Arbitrary Card where
  arbitrary :: Gen Card
arbitrary = [Gen Card] -> Gen Card
forall a. [Gen a] -> Gen a
oneof [CardSuit -> CardRank -> Card
Card (CardSuit -> CardRank -> Card)
-> Gen CardSuit -> Gen (CardRank -> Card)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen CardSuit
forall a. Arbitrary a => Gen a
arbitrary Gen (CardRank -> Card) -> Gen CardRank -> Gen Card
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen CardRank
forall a. Arbitrary a => Gen a
arbitrary, Card -> Gen Card
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Card
Back, JokerColor -> Card
Joker (JokerColor -> Card) -> Gen JokerColor -> Gen Card
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen JokerColor
forall a. Arbitrary a => Gen a
arbitrary, Trump -> Card
Trump (Trump -> Card) -> Gen Trump -> Gen Card
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Trump
forall a. Arbitrary a => Gen a
arbitrary]

instance Bounded Card where
  minBound :: Card
minBound = Card
Back
  maxBound :: Card
maxBound = Trump -> Card
Trump Trump
forall a. Bounded a => a
maxBound

instance Hashable Card

instance NFData Card

instance UnicodeCharacter CardSuit where
  toUnicodeChar :: CardSuit -> Char
toUnicodeChar = Int -> CardSuit -> Char
forall a. Enum a => Int -> a -> Char
mapFromEnum Int
_suitOffset
  fromUnicodeChar :: Char -> Maybe CardSuit
fromUnicodeChar = Int -> Char -> Maybe CardSuit
forall a. (Bounded a, Enum a) => Int -> Char -> Maybe a
mapToEnumSafe Int
_suitOffset
  fromUnicodeChar' :: Char -> CardSuit
fromUnicodeChar' = Int -> Char -> CardSuit
forall a. Enum a => Int -> Char -> a
mapToEnum Int
_suitOffset
  isInCharRange :: Char -> Bool
isInCharRange Char
c = Char
'\x2660' Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'\x2663'

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

-- | The unicode character that represents the /back/ of the card.
back :: Char
back :: Char
back = Char
'\x1f0a0'

-- | Convert the given 'CardSuit' and 'CardRank' to the equivalent unicode
-- character for this card.
card' ::
  -- | The given 'CardSuit' for the card.
  CardSuit ->
  -- | The given 'CardRank' for the card.
  CardRank ->
  -- | The corresponding unicode character with the given suit and rank.
  Char
card' :: CardSuit -> CardRank -> Char
card' CardSuit
s CardRank
r = Int -> Char
chr (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
shiftL (CardSuit -> Int
forall a. Enum a => a -> Int
fromEnum CardSuit
s) Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ CardRank -> Int
forall a. Enum a => a -> Int
fromEnum CardRank
r Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
0x1f0a1)

-- | Convert the given 'JokerColor' to the unicode character which represents
-- this joker color.
joker ::
  -- | The given 'JokerColor' to convert to a unicode character.
  JokerColor ->
  -- | The unicode character that represents the joker with the given color.
  Char
joker :: JokerColor -> Char
joker JokerColor
c = Int -> Char
chr (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
shiftL (JokerColor -> Int
forall a. Enum a => a -> Int
fromEnum JokerColor
c) Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
0x1f0bf)

-- | Convert the given 't:Trump' value to the unicode equivalent.
trump ::
  -- | The given 't:Trump' value to convert to a unicode character.
  Trump ->
  -- | The unicode character that represents the given 't:Trump' playing card.
  Char
trump :: Trump -> Char
trump Trump
t = Int -> Char
chr (Int
0x1f0e0 Int -> Int -> Int
forall a. Bits a => a -> a -> a
.|. Trump -> Int
forall a. Enum a => a -> Int
fromEnum Trump
t)

-- | Convert the given 'Card' object to its unicode equivalent.
card :: Card -> Char
card :: Card -> Char
card Card
Back = Char
back
card (Card CardSuit
s CardRank
r) = CardSuit -> CardRank -> Char
card' CardSuit
s CardRank
r
card (Joker JokerColor
c) = JokerColor -> Char
joker JokerColor
c
card (Trump Trump
t) = Trump -> Char
trump Trump
t

-- | /Swords/ is an alias for the /spades/ card suit.
pattern Swords :: CardSuit
pattern $mSwords :: forall {r}. CardSuit -> ((# #) -> r) -> ((# #) -> r) -> r
$bSwords :: CardSuit
Swords = Spades

-- | /Cups/ is an alias for the /hearts/ card suit.
pattern Cups :: CardSuit
pattern $mCups :: forall {r}. CardSuit -> ((# #) -> r) -> ((# #) -> r) -> r
$bCups :: CardSuit
Cups = Hearts

-- | /Pentacles/ is an alias for the /diamonds/ card suit.
pattern Pentacles :: CardSuit
pattern $mPentacles :: forall {r}. CardSuit -> ((# #) -> r) -> ((# #) -> r) -> r
$bPentacles :: CardSuit
Pentacles = Diamonds

-- | /Wands/ is an alias for the /clubs/ card suit.
pattern Wands :: CardSuit
pattern $mWands :: forall {r}. CardSuit -> ((# #) -> r) -> ((# #) -> r) -> r
$bWands :: CardSuit
Wands = Clubs

-- | In France, the /jack/ is sometimes called the /valet/.
pattern Valet :: CardRank
pattern $mValet :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> r) -> r
$bValet :: CardRank
Valet = Jack

-- | In Germany, Austria and Switzerland, the /jack/ is sometimes called the /bube/.
pattern Bube :: CardRank
pattern $mBube :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> r) -> r
$bBube :: CardRank
Bube = Jack

-- | In Germany and Switzerland, the /jack/ is sometimes called the /unter/.
pattern Unter :: CardRank
pattern $mUnter :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> r) -> r
$bUnter :: CardRank
Unter = Jack

-- | An alternative name for the /jack/ is /page/.
pattern Page :: CardRank
pattern $mPage :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> r) -> r
$bPage :: CardRank
Page = Jack

-- | In Italy, the /jack/ is sometimes called the /fante/.
pattern Fante :: CardRank
pattern $mFante :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> r) -> r
$bFante :: CardRank
Fante = Jack

-- | In France, the /knight/ is sometimes called the /chevalier/.
pattern Chevalier :: CardRank
pattern $mChevalier :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> r) -> r
$bChevalier :: CardRank
Chevalier = Knight

-- | In Germany, the /knight/ is sometimes called the /ober/.
pattern Ober :: CardRank
pattern $mOber :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> r) -> r
$bOber :: CardRank
Ober = Knight

-- | In Germany, the /knight/ is sometimes called the /ritter/.
pattern Ritter :: CardRank
pattern $mRitter :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> r) -> r
$bRitter :: CardRank
Ritter = Knight

-- | An alternative name for the /jack/ is /cavall/.
pattern Cavall :: CardRank
pattern $mCavall :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> r) -> r
$bCavall :: CardRank
Cavall = Knight

-- | An alternative name for the /jack/ is /cavaliere/.
pattern Cavaliere :: CardRank
pattern $mCavaliere :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> r) -> r
$bCavaliere :: CardRank
Cavaliere = Knight

-- | An alternative name for the /queen/ is /dame/.
pattern Dame :: CardRank
pattern $mDame :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> r) -> r
$bDame :: CardRank
Dame = Queen

-- | In Germany, the /queen/ is sometimes called the /königin/.
pattern Königin :: CardRank
pattern $mKönigin :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> r) -> r
$bKönigin :: CardRank
Königin = Queen

-- | In Italy, the /queen/ is sometimes called the /regina/.
pattern Regina :: CardRank
pattern $mRegina :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> r) -> r
$bRegina :: CardRank
Regina = Queen

-- | In France, the /king/ is sometimes called the /roi/.
pattern Roi :: CardRank
pattern $mRoi :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> r) -> r
$bRoi :: CardRank
Roi = King

-- | In Germany, the /king/ is sometimes called the /könig/.
pattern König :: CardRank
pattern $mKönig :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> r) -> r
$bKönig :: CardRank
König = King

-- | In Italy, the /queen/ is sometimes called the /re/.
pattern Re :: CardRank
pattern $mRe :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> r) -> r
$bRe :: CardRank
Re = King

-- | The trump card with number /I/ is named /individual/.
pattern Individual :: Trump
pattern $mIndividual :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bIndividual :: Trump
Individual = Trump1

-- | The trump card with number /II/ is named /childhood/.
pattern Childhood :: Trump
pattern $mChildhood :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bChildhood :: Trump
Childhood = Trump2

-- | The trump card with number /III/ is named /youth/.
pattern Youth :: Trump
pattern $mYouth :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bYouth :: Trump
Youth = Trump3

-- | The trump card with number /IV/ is named /maturity/.
pattern Maturity :: Trump
pattern $mMaturity :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bMaturity :: Trump
Maturity = Trump4

-- | The trump card with number /V/ is named /old age/.
pattern OldAge :: Trump
pattern $mOldAge :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bOldAge :: Trump
OldAge = Trump5

-- | The trump card with number /VI/ is named /morning/.
pattern Morning :: Trump
pattern $mMorning :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bMorning :: Trump
Morning = Trump6

-- | The trump card with number /VII/ is named /afternoon/.
pattern Afternoon :: Trump
pattern $mAfternoon :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bAfternoon :: Trump
Afternoon = Trump7

-- | The trump card with number /VIII/ is named /evening/.
pattern Evening :: Trump
pattern $mEvening :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bEvening :: Trump
Evening = Trump8

-- | The trump card with number /IX/ is named /night/.
pattern Night :: Trump
pattern $mNight :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bNight :: Trump
Night = Trump9

-- | The trump card with number /X/ is named /earth/.
pattern Earth :: Trump
pattern $mEarth :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bEarth :: Trump
Earth = Trump10

-- | The trump card with number /X/ is named /air/.
pattern Air :: Trump
pattern $mAir :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bAir :: Trump
Air = Trump10

-- | The trump card with number /XI/ is named /water/.
pattern Water :: Trump
pattern $mWater :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bWater :: Trump
Water = Trump11

-- | The trump card with number /XI/ is named /fire/.
pattern Fire :: Trump
pattern $mFire :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bFire :: Trump
Fire = Trump11

-- | The trump card with number /XII/ is named /dance/.
pattern Dance :: Trump
pattern $mDance :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bDance :: Trump
Dance = Trump12

-- | The trump card with number /XIII/ is named /shopping/.
pattern Shopping :: Trump
pattern $mShopping :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bShopping :: Trump
Shopping = Trump13

-- | The trump card with number /XIV/ is named /open air/.
pattern OpenAir :: Trump
pattern $mOpenAir :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bOpenAir :: Trump
OpenAir = Trump14

-- | The trump card with number /XV/ is named /visual arts/.
pattern VisualArts :: Trump
pattern $mVisualArts :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bVisualArts :: Trump
VisualArts = Trump15

-- | The trump card with number /XVI/ is named /spring/.
pattern Spring :: Trump
pattern $mSpring :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bSpring :: Trump
Spring = Trump16

-- | The trump card with number /XVII/ is named /summer/.
pattern Summer :: Trump
pattern $mSummer :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bSummer :: Trump
Summer = Trump17

-- | The trump card with number /XVIII/ is named /autumn/.
pattern Autumn :: Trump
pattern $mAutumn :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bAutumn :: Trump
Autumn = Trump18

-- | The trump card with number /XIX/ is named /winter/.
pattern Winter :: Trump
pattern $mWinter :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bWinter :: Trump
Winter = Trump19

-- | The trump card with number /XX/ is named the /game/.
pattern Game :: Trump
pattern $mGame :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bGame :: Trump
Game = Trump20

-- | The trump card with number /XXI/ is named /collective/.
pattern Collective :: Trump
pattern $mCollective :: forall {r}. Trump -> ((# #) -> r) -> ((# #) -> r) -> r
$bCollective :: Trump
Collective = Trump21