typy, definice funkcí, pattern matching, seznamy, základní vestavěné funkce a operátory: :load, :type (:t), (++), (:), (==), fraenklovy termy pro seznamy

-- tři ekvivalentní definice funkce faktoriál:
 
faktorial :: Integer -> Integer  -- explicitní typová definice
faktorial n = if n==0 then 1 else n*(faktorial (n-1))
 
faktorial1 0 = 1
faktorial1 n = n*(faktorial1 (n-1))
 
faktorial'' n | n==0 = 1
              | otherwise = n*(faktorial'' (n-1))
 

car (e : _) = e -- příklad možné implementace car ze Scheme
cdr (_ : ls) = ls -- příklad možné implementace car ze Scheme
cons e ls = (e : ls) -- příklad možné implementace car ze Scheme
 
head'' (x:_) = x -- vestavěná fce head odpovídá car ve Scheme
tail'' (_:xs) = xs -- vestavěná fce tail odpovídá cdr ve Scheme
 
[1..100]     -- seznam čísel od 1 do 100 včetně
[1,3..100]   -- seznam lichých čísel od 1 do 100 včetně
[2,4..100]   -- seznam sudých čísel od 1 do 100 včetně
[1..]        -- seznam všech čísel od 1 
[1,3..]      -- seznam všech lichých čísel od 1

-- implementace algoritmu QuickSort v Haskellu:
quicksort [] = []
quicksort (x:xs) = (quicksort [e|e<-xs,e<x]) ++ [x] ++ (quicksort [e|e<-xs,e>=x])

lambda termy, curryfikace, grafická syntaxe, @, let, where, typové třídy (class, instance, deriving), základní typové třídy (Eq, Ord, Num, Show)

--Příklad lambda termu
Main> map (\ x -> -x) [1..10]
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]
 
--Příklad curryfikace funkce -
Main> map ((-) 0) [1..10]
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]
 
--Příklad curryfikace infixové funkce -
Main> map (0-) [1..10]
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]
 
--Příklad let konstrukce
Main> let minus = (0-) in map minus [1..10]
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]
 
--Příklad let konstrukce
Main> let {minus = (0-); seznam = [1..10]} in map minus seznam
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]
 
--Příklad where konstrukce
Main> map minus seznam where {minus = (0-); seznam = [1..10]}
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]

msort [] = []
msort [x] = [x]
msort ls = merge sas sbs where
	(las,lbs) = split ls where
		split [] = ([],[])
		split [x] = ([x],[])
		split (x:y:ls) = (x:xs,y:ys) where
			(xs,ys) = split ls
	sas = msort las
	sbs = msort lbs
	merge [] ls = ls
	merge ls [] = ls
	merge zs@(x:xs) qs@(y:ys) | (x <= y) = (x : merge xs qs)
	                          | otherwise = merge qs zs

data Barvy = Modra | Zelena | Cervena | Zluta | Bila
 
-- namísto následující konstrukce SeznamBarev pro seznam barev: 
data SeznamBarev = Cons Barvy SeznamBarev | Prazdny
-- raději použijeme parametrický typ:
data Seznam a = Cons a (Seznam a) | Prazdny
 
-- vestavěné seznamy: data [a] = a : [a] | []

data Barvy = Modra | Zelena | Cervena deriving (Eq,Ord)
 
instance Show Barvy where
	show Modra = "BLUE"
	show Zelena = "GREEN"
	show Cervena = "RED"
 
data Strom a = Uzel a [Strom a] | Listek a deriving Show
 
class W a where
	w :: a -> Bool
 
instance W Barvy where
	w Modra = True
	w Cervena = False
	w _ = error "Chyba"