module Main where

data Suit = Club | Diamond | Heart | Spade
     deriving (Read, Show, Enum, Eq, Ord)

data CardValue = Two | Three | Four | Five | Six | Seven | Eight | Nine | Ten | Jack | Queen | King | Ace
     deriving (Read, Show, Enum, Eq, Ord)

data Card = Card {value :: CardValue, suit :: Suit}
     deriving (Read, Show, Eq)

instance Ord Card where
         compare c1 c2 = compare (value c1, suit c1) (value c2, suit c2)

instance Enum Card where
         toEnum n  = let (v, s) = n `divMod`  4  in Card (toEnum v) (toEnum s)
         fromEnum c = fromEnum (value c) *  4  + fromEnum (suit c)

type Deck = [Card]

deck :: Deck
deck = [Card val su | val <- [Two .. Ace], su <- [Club .. Spade]]


main = print deck

data Card value suit = Card (CardValue value) (Suit suit)
     deriving (Read, Show, Eq)

let (v, s) = ... in Card (toEnum v) (toEnum s)

deck :: Deck // инициализация переменной типа Deck?

module Main where

data Bogus = Bogus {valueBogus :: Char}

class BogusSuper b where
      bogusSuper :: b -> [Char]

class BogusSuper b => BogusChild b where
      bogusChild :: b -> [Char]

instance BogusChild Bogus where
         bogusChild a = [valueBogus a, valueBogus a, valueBogus a]

instance BogusSuper Bogus where
         bogusSuper a = [valueBogus a]

test = Bogus 'b'

main = do print (bogusSuper test)
          print (bogusChild test)

module Main where


factorial  0  =  1 
factorial n = n * factorial (n -  1 )

 
calc s b lm ln cl c t = let s        = c * b * t
                            ks  1   1    = s
                            ks  1  ln  = ks  1  (ln -  1 ) + s ^ ln
                            ks lm ln = ks  1  ln - ks  1  lm
                            v c  1     = ks lm ln * ( 1  - exp (-c / ks lm ln))
                            v c cl   = ks lm ln * ( 1  - exp (-v c (cl -  1 ) / ks lm ln))
                            srt c  1   =  1 
                            srt c cl =  1  - srt c (cl -  1 ) * ( 1  - v c cl / ks lm ln)
                            sr       =  1  - ( 1  - srt c cl) ^ t
                        in [s, sr]

calc16 s lm ln cl c t = calc s  16  lm ln cl c t


r = calc16  3   1   3   3   3   3 


main = print r

>..\ghc --make test.hs
[ 1  of  1 ] Compiling Main             ( test.hs, test.o )

test.hs: 57 : 14 :
    Ambiguous type variable `t' in the constraints:
      `Integral t' arising from a use of `calc16' at test.hs:57:14-31
      `Floating t' arising from a use of `calc16' at test.hs: 57 : 14 - 31 
    Possible cause: the monomorphism restriction applied to the following:
      calc_result :: [t] (bound at test.hs: 57 : 0 )
    Probable fix: give these definition(s) an explicit type signature
                  or use -XNoMonomorphismRestriction

sr       =  1  - ( 1  - srt c cl) ^ t

                            srt c cl =  1  - srt c (cl -  1 ) * ( 1  - v c cl / ks lm ln)
                            -- sr       = 1 - (1 - srt c cl) ^ t
                        in [s, srt c cl]

ks  1  ln  = ks  1  (ln -  1 ) + s ^ ln

ks lm ln * ( 1  - exp (-c / ks lm ln))

(ks lm ln) * ( 1  - exp (-c / (ks lm ln)))

                            ks  1   1    = s
                            ks  1  ln  = ks  1  (ln -  1 ) + s ^ ln
                            ks lm ln = ks  1  ln - ks  1  lm

(^) :: (Num a, Integral b) => a -> b -> a
(^) s ln -- ln :: Integral
(-) :: a -> a -> a
(-) ln  1  -- почему нельзя вывести как Integral, если в других местах накладывается такое ограничение?

ks lm ln * ( 1  - exp (-c / ks lm ln))

                          c
                   (- ---------)
                       f(x, y)
f(x, y) * ( 1  - e ^               )