data Pravdivost
  = Ano
  | Ne

{- pouziti: Ano se vypise jako Jo diky pretizenemu show.
 - 'show' je jinak zcela typicka overloadovana funkce -- pro kazdy datovy typ
 - funguje uplne jinak. -}
instance Show Pravdivost where
  show Ano = "Jo"
  show Ne = "Nein"

{- Typova trida na vsechny slepitelne veci -}
class Slep a where
  slep :: a -> a -> a

{- Lepit k sobe jdou integery (scitanim) -}
instance Slep Integer where
  slep = (+)

{- Lepit k sobe jdou i seznamy (spojovanim seznamu) -}
instance Slep [a] where
  slep = (++)

{- Lepit k sobe jdou i Booly (andem) -}
instance Slep Bool where
  slep = (&&)

{- pouziti:
 -  slep 5 7 == 12
 -  slep [5] [7,8] == [5,7,8]
 -}
{- Typova trida na integery modulo 7. "newtype" je tosame jako "data", ale
 - funguje to jen na data ktere obsahuji presne jednu moznost s presne jednim
 - datovym prvkem, a v runtime to je rychlejsi protoze v prubehu kompilace se
 - newtype "odmaze". -}
newtype I7 =
  I7 Int
  deriving (Show)

{- Data typu I7 jde pouzivat jako cisla -}
instance Num I7 where
  I7 a + I7 b = I7 $ (a + b) `mod` 7
  I7 a - I7 b = I7 $ (a - b) `mod` 7
  I7 a * I7 b = I7 $ (a * b) `mod` 7
  negate (I7 a) = I7 $ negate a `mod` 7
  abs = id
  signum (I7 0) = I7 0
  signum _ = I7 1
  fromInteger a = I7 $ fromInteger a `mod` 7

{- Priklad: I7 5 + 4 * 2 + 1 == I7 0 -}
{- definice stromu -}
data Strom a
  = Vetev (Strom a)
          a
          (Strom a)
  | Nil

{- Pokud strom obsahuje neco show-ovatelneho, tak jde taky show-ovat -}
instance Show a => Show (Strom a) where
  show Nil = "{}"
  show (Vetev leva hod prava) =
    "{" ++ show leva ++ " " ++ show hod ++ " " ++ show prava ++ "}"

{- Strom je kontejner, a jde na nej pouzivat fmap (coz je genericky map)
 - priklad:
 - > fmap (reverse.show.(*10).succ) (Vetev (Vetev Nil 1 Nil) 2 Nil)
 - {{{} "02" {}} "03" {}}
 -}
instance Functor Strom where
  fmap f Nil = Nil
  fmap f (Vetev leva hod prava) = Vetev (fmap f leva) (f hod) (fmap f prava)

{- seznamy jde pouzivat a scitat jako vektory cisel
 - priklad:
 - 10+[1,2,3]+[4,5,6]*[7,8,9] == [39,52,67]
 -
 - Navic seznamy jsou ted numericke, takze tranzitivne plati, ze seznamy
 - seznamu jsou taky numericke:
 - [[1,2,3],4,[5,6,7]] * [3,[4,6],5] == [[3,6,9],[16,24],[25,30,35]]
 -}
instance Num a => Num [a] where
  (+) = zipWith (+)
  (-) = zipWith (-)
  (*) = zipWith (*)
  negate = map negate
  abs = map abs
  signum = map signum
  fromInteger = repeat . fromInteger

fibs = 0 : 1 : fibs + tail fibs --extra semanticka ohavnost nakonec