Styjun

I have this type

type Card = (CardValue,Suite)

I want to write a function to show color based on Card.Suite value

colour :: Card -> Colour
colour card = if card.Suite == Spades then Red else Black

This code just illustrates what I want to achieve. I don't know how to actually get suite value from Card(CardValue,Suite).

The type keyword declares a new type synonim, not a new type. In your code a Card is just a tuple of CardValue and Suite.

To access pair's elements either use fst and snd:

colour card = if snd card == Spades then Red else Black

or pattern-match the argument:

colour (value,suite) = if suite == Spades then Red else Black

type Card = (CardValue, Suit) makes Card a type alias for a tuple of CardValue and Suit data. That might not be the best data structure (a data member using record syntax seems better) but it's trivial to do what you want:

data Suit = Spades | Clubs | Hearts | Diamonds
data Color = Red | Black

type Card = (CardValue, Suit)

getSuitColor :: Card -> Color
getSuitColor (_, Spades) = Black
getSuitColor (_, Clubs) = Black
getSuitColor _ = Red

Or you could use guards to do the same

getSuitColor :: Card -> Color
getSuitColor (_, suit)
 | suit == Spades = Black
 | suit == Clubs = Black
 | otherwise = Red

However you'll have to use deriving Eq on your Suit to do that (since otherwise you can't == it!)

If this were me I'd probably use that record syntax I mentioned above

data Card rank :: CardValue
 , suit :: Suit
 

Which then means you have to construct your Cards, as they're separate types.

myOldCard = (3, Spades)
myNewCard = Card 3 Spades

But it means you have ready-made lookups into them.

getColor :: Card -> Color
getColor = determineColor . suit
 where
 determineColor :: Suit -> Color
 determineColor Spades = Black
 determineColor Clubs = Black
 determineColor _ = Red