Функции для работы со списками и игральные карты

data Mast = Diamonds | Hearts | Clubs | Spades deriving (Eq, Ord, Show)
 
data Dostoinstvo = Two | Three | Four | Five | Six | Seven | Eight | Nine | Ten | Jack | Queen | King | Ace deriving (Eq, Ord, Show)
 
data Karta = Karta Dostoinstvo Mast deriving (Eq, Ord, Show)
 
isMinor :: Karta -> Bool
isMinor (Karta x y) = if (x==Jack)||(x==Queen)||(x==King)||(x==Ace) then False else True
 
beats :: Karta -> Karta -> Bool
beats (Karta x1 y1) (Karta x2 y2) = if (y1==y2)&&(x1>x2) then True else False
 
beats2 :: Mast -> Karta -> Karta -> Bool
beats2 y (Karta x1 y1) (Karta x2 y2) = if (((y1==y2)&&(x1>x2))||(((y1==y)||(y2==y))&&(x1>x2) )||((y1==y)&&(y2/=y))) then True else False
 
sameSuit :: [Karta] -> Bool
sameSuit (Karta f1 s1 : (Karta f2 s2 : xs)) = if (s1==s2) then sameSuit (Karta f2 s2 : xs) else False
sameSuit xs = if xs==[] then False else True
 
beatsList :: [Karta] -> Karta -> Mast -> [Karta]
 
beatsList cs card koz = go cs []
 
where go (x:xs) acc = go xs (if beats2 koz x card then x:acc else acc)
 
go [] acc = acc
 
ochki :: Dostoinstvo -> [Integer]
ochki Two = [2]
ochki Three = [3]
ochki Four = [4]
ochki Five = [5]
ochki Six = [6]
ochki Seven = [7]
ochki Eight = [8]
ochki Nine = [9]
ochki Ten = [10]
ochki Jack = [10]
ochki Queen = [10]
ochki King = [10]
ochki Ace = [1, 11]
 
points :: [Karta] -> [Integer]
points xs = let { nub (x:xs) acc = nub [x1 | x1 <- xs, x1/=x] (x:acc);
nub _ acc = acc }
in nub (rec' [] xs) []
where rec' rs [] = rs
rec' [] (Karta x _: xs) = rec' (ochki x) xs
rec' rs (Karta x _: xs) = rec' [r+a | a <- ochki x, r <- rs] xs

data List a = Nil | Cons a (List a)

data List a = Nil | a ‘Cons‘ (List a)

-- Это не настоящий код языка Haskell data [a] = [] | a : [a]

headList (Cons x _) = x
headList Nil    = error "headList: empty list"
tailList (Cons _ y) = y
tailList Nil    = error "tailList: empty list"

Main>headList (Cons 1 (Cons 2 Nil)) 1
Main>tailList (Cons 1 (Cons 2 Nil)) Cons 2 Nil

data MyList a = Nil | a `Cons` (MyList a) deriving Show
 
headList :: MyList a -> a
headList (Cons x _) = x
 
tailList :: MyList a -> MyList a
tailList (Cons _ y) = y
 
lengthList :: MyList a -> Int
lengthList Nil = 0
lengthList (Cons _ x) = 1 + lengthList x 
 
nthList :: MyList a -> Int -> a
nthList x 1 = headList x
nthList x n = nthList (tailList x) (n-1) 
 
fromList :: MyList Int -> [Int]
fromList Nil = []
fromList (Cons x y) = x : (fromList y)
 
toList :: [Int] -> MyList Int
toList [] = Nil
toList (x:xs)= (Cons x (toList xs))
 
removeNeg :: MyList Integer -> MyList Integer
removeNeg Nil = Nil
removeNeg (Cons x y) | (x < 0) = removeNeg y
                     | otherwise = (Cons x (removeNeg y))

data List a = Nil | Cons a (List a)
 
instance Show a => Show (List a) where
    show = show . toList
 
headList (Cons x _) = x
headList Nil = error "headList: empty list"
 
tailList (Cons _ xs) = xs
tailList Nil = error "tailList: empty list"
 
lengthList Nil = 0
lengthList xs = succ $ tailList xs
 
nth Nil _ = error "nth: index too large"
nth xs 0 = headList xs
nth xs n =
    if n < 0
        then error "nth: negative index"
        else nth (tailList xs) (pred n)
 
removeNegative = filterList (not . (<0))
 
filterList p Nil = Nil
filterList p (Cons x xs) =
    (if p x then (Cons x) else id) $ filterList p xs
    
fromList [] = Nil
fromList (x:xs) = Cons x (fromList xs)
 
toList Nil = []
toList (Cons x xs) = x : (toList xs)

lengthList xs = succ (lengthList . tailList $ xs)