Začínám s Haskell - 2. kapitola

Datový typy v Haskell

- datové typy se odvozují
:t    příkaz pro vrácení datového typu
:t 'a'    vrací: 'a' :: Char

Typ fce - typ fce je tvořen z parametrů a návratové hodnoty
definice fce se 3 parametry typu int a výsledek int:


addThree :: Int -> Int -> Int -> Int
addThree x y z = x + y + z

Datové typy:
Int celá čísla
Integer taky celá čísla, akorát s větším rozsahem (např. na počítání faktoriál 9999)
Float , Double , Bool , Char 
Tuples (n-tice) - jejich datový typ závisí na velikosti a typ vnitřních prvků

Type Variable (typová proměnná)
- u fcí - typ může být jakýkoliv (jak Generics v Javě)

Typ fce fst (vrací 1.prvek ve 2-prvkovém tuple):
snd :: (a, b) -> b    znamená: jako parametr bere 2 prvky různého typu, a vrátí prvek stejného typu jako druhá proměnná

Type class (typová třída)
- definuje vlastnost, kterou všechny instance této třídy musí mít

(==) :: (Eq a) => a -> a -> Bool    znamená: funkce rovná se bere jako parametr 2 prvky stejného typové třídy Eq (tzn. tyto prvky musí být instancí této typové třídy) a vrací typ Bool

Typové třídy
Eq    == a /=, všechny předchozí zmíněné typy (kromě fcí ) jsou instancí Eq

Ord    porovnání (např. >=), všechny předchozí zmíněné typy (kromě fcí ) jsou instancí Eq

Show    převede do řetězce - fce show

Read    načte řetězec a vrátí typ - fce read: je potřeba ji buď použít v kontextu nebo specifikovat typ (type annotation)
read "[1,2,3,4]" ++ [3]      použitý v kontextu
read "5" :: Int                   type annotation

Enum    sekvenčně seřazené typy (použití v ranges). Má definované předchůdce (fce pred) a následníky (fce succ).

Bounded    mají spodní a horní hranici (např. Int nebo Bool nebo Tuples složené z Bounded prvků). Pro zjištění hranic jsou fce minBound a maxBound (např. minBound :: Int = -2147483648 

Num     instance se chovají jako čísla. Instance této třídy musí být zároveň instancí Show a Eq.

Integral     jen celá čísla (Int a Integer)

Floating     čísla s des. čárkou (Float a Double)

fromIntegral    změní celé číslo na obecné číslo
fromIntegral :: (Num b, Integral a) => a -> b
fromIntegral (length [1,2,3,4]) + 3.2   
znamená: length vrací celé číslo a sečtením s 3.2 by házelo chybu (4 + 3.2 jde, protože Haskell bere 4 jako typ floating), proto musíme přetypovat na obecné číslo pomocí fromIntegral