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

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

instance Hashable CardSuit

instance NFData CardSuit

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

instance Hashable JokerColor

instance NFData JokerColor

-- | A data type for the trump cards, often used for /tarot/.
data Trump
  = Fool  -- ^ The /fool/ trump card, this tarot card is normally not numbered.
  | Trump1  -- ^ Tarot card /I/.
  | Trump2  -- ^ Tarot card /II/.
  | Trump3  -- ^ Tarot card /III/.
  | Trump4  -- ^ Tarot card /IV/.
  | Trump5  -- ^ Tarot card /V/.
  | Trump6  -- ^ Tarot card /VI/.
  | Trump7  -- ^ Tarot card /VII/.
  | Trump8  -- ^ Tarot card /VIII/.
  | Trump9  -- ^ Tarot card /IX/.
  | Trump10  -- ^ Tarot card /X/.
  | Trump11  -- ^ Tarot card /XI/.
  | Trump12  -- ^ Tarot card /XII/.
  | Trump13  -- ^ Tarot card /XIII/.
  | Trump14  -- ^ Tarot card /XIV/.
  | Trump15  -- ^ Tarot card /XV/.
  | Trump16  -- ^ Tarot card /XVI/.
  | Trump17  -- ^ Tarot card /XVII/.
  | Trump18  -- ^ Tarot card /XVIII/.
  | Trump19  -- ^ Tarot card /XIX/.
  | Trump20  -- ^ Tarot card /XX/.
  | Trump21  -- ^ Tarot card /XXI/.
  deriving (Trump
Trump -> Trump -> Bounded Trump
forall a. a -> a -> Bounded a
maxBound :: Trump
$cmaxBound :: Trump
minBound :: Trump
$cminBound :: Trump
Bounded, Typeable Trump
DataType
Constr
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 -> DataType
Trump -> Constr
(forall b. Data b => b -> b) -> Trump -> Trump
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Trump -> c Trump
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cTrump21 :: Constr
$cTrump20 :: Constr
$cTrump19 :: Constr
$cTrump18 :: Constr
$cTrump17 :: Constr
$cTrump16 :: Constr
$cTrump15 :: Constr
$cTrump14 :: Constr
$cTrump13 :: Constr
$cTrump12 :: Constr
$cTrump11 :: Constr
$cTrump10 :: Constr
$cTrump9 :: Constr
$cTrump8 :: Constr
$cTrump7 :: Constr
$cTrump6 :: Constr
$cTrump5 :: Constr
$cTrump4 :: Constr
$cTrump3 :: Constr
$cTrump2 :: Constr
$cTrump1 :: Constr
$cFool :: Constr
$tTrump :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> Trump -> m Trump
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Trump -> m Trump
gmapQi :: Int -> (forall d. Data d => d -> u) -> Trump -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Trump -> u
gmapQ :: (forall d. Data d => d -> u) -> Trump -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Trump -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Trump -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Trump -> r
gmapT :: (forall b. Data b => b -> b) -> Trump -> Trump
$cgmapT :: (forall b. Data b => b -> b) -> Trump -> Trump
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Trump)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Trump)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Trump)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Trump)
dataTypeOf :: Trump -> DataType
$cdataTypeOf :: Trump -> DataType
toConstr :: Trump -> Constr
$ctoConstr :: Trump -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Trump
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Trump
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Trump -> c Trump
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Trump -> c Trump
$cp1Data :: Typeable 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
enumFromThenTo :: Trump -> Trump -> Trump -> [Trump]
$cenumFromThenTo :: Trump -> Trump -> Trump -> [Trump]
enumFromTo :: Trump -> Trump -> [Trump]
$cenumFromTo :: Trump -> Trump -> [Trump]
enumFromThen :: Trump -> Trump -> [Trump]
$cenumFromThen :: Trump -> Trump -> [Trump]
enumFrom :: Trump -> [Trump]
$cenumFrom :: Trump -> [Trump]
fromEnum :: Trump -> Int
$cfromEnum :: Trump -> Int
toEnum :: Int -> Trump
$ctoEnum :: Int -> Trump
pred :: Trump -> Trump
$cpred :: Trump -> Trump
succ :: Trump -> Trump
$csucc :: Trump -> Trump
Enum, Trump -> Trump -> Bool
(Trump -> Trump -> Bool) -> (Trump -> Trump -> Bool) -> Eq Trump
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Trump -> Trump -> Bool
$c/= :: Trump -> Trump -> Bool
== :: Trump -> Trump -> Bool
$c== :: 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
$cto :: forall x. Rep Trump x -> Trump
$cfrom :: forall x. Trump -> Rep Trump x
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
min :: Trump -> Trump -> Trump
$cmin :: Trump -> Trump -> Trump
max :: Trump -> Trump -> Trump
$cmax :: Trump -> Trump -> Trump
>= :: Trump -> Trump -> Bool
$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
compare :: Trump -> Trump -> Ordering
$ccompare :: Trump -> Trump -> Ordering
$cp1Ord :: Eq 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
readListPrec :: ReadPrec [Trump]
$creadListPrec :: ReadPrec [Trump]
readPrec :: ReadPrec Trump
$creadPrec :: ReadPrec Trump
readList :: ReadS [Trump]
$creadList :: ReadS [Trump]
readsPrec :: Int -> ReadS Trump
$creadsPrec :: Int -> ReadS 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
showList :: [Trump] -> ShowS
$cshowList :: [Trump] -> ShowS
show :: Trump -> String
$cshow :: Trump -> String
showsPrec :: Int -> Trump -> ShowS
$cshowsPrec :: Int -> 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
  = Back  -- ^ The back of the card.
  | Card CardSuit CardRank  -- ^ A card that is a combination of a 'CardSuit' and a 'CardRank'. There are 56 possibilities.
  | Joker JokerColor  -- ^ Three possible 'JokerColor' cards.
  | Trump Trump -- The 21 't:Trump' cards (together with the 'Fool', which is usually not numbered).
  deriving (Typeable Card
DataType
Constr
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 -> DataType
Card -> Constr
(forall b. Data b => b -> b) -> Card -> Card
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Card -> c Card
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cTrump :: Constr
$cJoker :: Constr
$cCard :: Constr
$cBack :: Constr
$tCard :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> Card -> m Card
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Card -> m Card
gmapQi :: Int -> (forall d. Data d => d -> u) -> Card -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Card -> u
gmapQ :: (forall d. Data d => d -> u) -> Card -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Card -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Card -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Card -> r
gmapT :: (forall b. Data b => b -> b) -> Card -> Card
$cgmapT :: (forall b. Data b => b -> b) -> Card -> Card
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Card)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Card)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Card)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Card)
dataTypeOf :: Card -> DataType
$cdataTypeOf :: Card -> DataType
toConstr :: Card -> Constr
$ctoConstr :: Card -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Card
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Card
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Card -> c Card
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Card -> c Card
$cp1Data :: Typeable Card
Data, Card -> Card -> Bool
(Card -> Card -> Bool) -> (Card -> Card -> Bool) -> Eq Card
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Card -> Card -> Bool
$c/= :: Card -> Card -> Bool
== :: Card -> Card -> Bool
$c== :: 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
$cto :: forall x. Rep Card x -> Card
$cfrom :: forall x. Card -> Rep Card x
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
min :: Card -> Card -> Card
$cmin :: Card -> Card -> Card
max :: Card -> Card -> Card
$cmax :: Card -> Card -> Card
>= :: Card -> Card -> Bool
$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
compare :: Card -> Card -> Ordering
$ccompare :: Card -> Card -> Ordering
$cp1Ord :: Eq 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
readListPrec :: ReadPrec [Card]
$creadListPrec :: ReadPrec [Card]
readPrec :: ReadPrec Card
$creadPrec :: ReadPrec Card
readList :: ReadS [Card]
$creadList :: ReadS [Card]
readsPrec :: Int -> ReadS Card
$creadsPrec :: Int -> ReadS 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
showList :: [Card] -> ShowS
$cshowList :: [Card] -> ShowS
show :: Card -> String
$cshow :: Card -> String
showsPrec :: Int -> Card -> ShowS
$cshowsPrec :: Int -> 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 (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 (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

instance UnicodeText 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'
  :: CardSuit  -- ^ The given 'CardSuit' for the card.
  -> CardRank  -- ^ The given 'CardRank' for the card.
  -> Char  -- ^ The corresponding unicode character with the given suit and rank.
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
  :: JokerColor  -- ^ The given 'JokerColor' to convert to a unicode character.
  -> Char  -- ^ The unicode character that represents the joker with the given color.
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
  :: Trump  -- ^ The given 't:Trump' value to convert to a unicode character.
  -> Char  -- ^ The unicode character that represents the given 't:Trump' playing card.
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 $bSwords :: CardSuit
$mSwords :: forall r. CardSuit -> (Void# -> r) -> (Void# -> r) -> r
Swords = Spades

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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