{-# 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
forall a. a -> a -> Bounded a
maxBound :: CardSuit
$cmaxBound :: CardSuit
minBound :: CardSuit
$cminBound :: CardSuit
Bounded, Typeable CardSuit
CardSuit -> DataType
CardSuit -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> CardSuit -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CardSuit -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CardSuit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CardSuit -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
Data, Int -> CardSuit
CardSuit -> Int
CardSuit -> [CardSuit]
CardSuit -> CardSuit
CardSuit -> CardSuit -> [CardSuit]
CardSuit -> CardSuit -> CardSuit -> [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
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. 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
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
Ord, ReadPrec [CardSuit]
ReadPrec CardSuit
Int -> ReadS CardSuit
ReadS [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
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
  = -- | 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
forall a. a -> a -> Bounded a
maxBound :: CardRank
$cmaxBound :: CardRank
minBound :: CardRank
$cminBound :: CardRank
Bounded, Typeable CardRank
CardRank -> DataType
CardRank -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> CardRank -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CardRank -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CardRank -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CardRank -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
Data, Int -> CardRank
CardRank -> Int
CardRank -> [CardRank]
CardRank -> CardRank
CardRank -> CardRank -> [CardRank]
CardRank -> CardRank -> CardRank -> [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
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. 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
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
Ord, ReadPrec [CardRank]
ReadPrec CardRank
Int -> ReadS CardRank
ReadS [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
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
  = -- | The /red/ joker.
    Red
  | -- | The /black/ joker.
    Black
  | -- | The /white/ joker.
    White
  deriving (JokerColor
forall a. a -> a -> Bounded a
maxBound :: JokerColor
$cmaxBound :: JokerColor
minBound :: JokerColor
$cminBound :: JokerColor
Bounded, Typeable JokerColor
JokerColor -> DataType
JokerColor -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> JokerColor -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> JokerColor -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> JokerColor -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> JokerColor -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
Data, Int -> JokerColor
JokerColor -> Int
JokerColor -> [JokerColor]
JokerColor -> JokerColor
JokerColor -> JokerColor -> [JokerColor]
JokerColor -> JokerColor -> JokerColor -> [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
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. 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
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
Ord, ReadPrec [JokerColor]
ReadPrec JokerColor
Int -> ReadS JokerColor
ReadS [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
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
  = -- | 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
forall a. a -> a -> Bounded a
maxBound :: Trump
$cmaxBound :: Trump
minBound :: Trump
$cminBound :: Trump
Bounded, Typeable Trump
Trump -> DataType
Trump -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> Trump -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Trump -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Trump -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Trump -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
Data, Int -> Trump
Trump -> Int
Trump -> [Trump]
Trump -> Trump
Trump -> Trump -> [Trump]
Trump -> Trump -> Trump -> [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
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. 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
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
Ord, ReadPrec [Trump]
ReadPrec Trump
Int -> ReadS Trump
ReadS [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
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
  = -- | 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
Card -> DataType
Card -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> Card -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Card -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Card -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Card -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
Data, Card -> Card -> Bool
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. 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
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
Ord, ReadPrec [Card]
ReadPrec Card
Int -> ReadS Card
ReadS [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
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 = forall a. (Bounded a, Enum a) => Gen a
arbitraryBoundedEnum

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

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

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

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

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

instance Hashable Card

instance NFData Card

instance UnicodeCharacter CardSuit where
  toUnicodeChar :: CardSuit -> Char
toUnicodeChar = forall a. Enum a => Int -> a -> Char
mapFromEnum Int
_suitOffset
  fromUnicodeChar :: Char -> Maybe CardSuit
fromUnicodeChar = forall a. (Bounded a, Enum a) => Int -> Char -> Maybe a
mapToEnumSafe Int
_suitOffset
  fromUnicodeChar' :: Char -> CardSuit
fromUnicodeChar' = forall a. Enum a => Int -> Char -> a
mapToEnum Int
_suitOffset
  isInCharRange :: Char -> Bool
isInCharRange Char
c = Char
'\x2660' forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c 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 (forall a. Bits a => a -> Int -> a
shiftL (forall a. Enum a => a -> Int
fromEnum CardSuit
s) Int
4 forall a. Num a => a -> a -> a
+ forall a. Enum a => a -> Int
fromEnum CardRank
r 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 (forall a. Bits a => a -> Int -> a
shiftL (forall a. Enum a => a -> Int
fromEnum JokerColor
c) Int
4 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 forall a. Bits a => a -> a -> a
.|. 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 -> ((# #) -> r) -> ((# #) -> r) -> r
Swords = Spades

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

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

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

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

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

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

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

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

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

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

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

-- | An alternative name for the /queen/ is /dame/.
pattern Dame :: CardRank
pattern $bDame :: CardRank
$mDame :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> 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 -> ((# #) -> r) -> ((# #) -> r) -> r
Königin = Queen

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

-- | In France, the /king/ is sometimes called the /roi/.
pattern Roi :: CardRank
pattern $bRoi :: CardRank
$mRoi :: forall {r}. CardRank -> ((# #) -> r) -> ((# #) -> 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 -> ((# #) -> r) -> ((# #) -> r) -> r
König = King

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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