Přehled syntaxe Haskellu

Základní vlastnosti jazyka

• norma Haskell98, nepatrný update v Haskell 2010
• čistě funkcionální, referenční transparentnost
• bez implicitních side-efektů nebo přístupu ke globálním datům
• silně a staticky typovaný, s automatickým typováním
• líně vyhodnocovaný (implicitně)
• přehled obsahu některých standardních knihoven
• podrobnosti najdete přímo v normě (je celkem čitelná)

Názvy identifikátorů a operátorů

• identifikátor začíná písmenem a každý další znak je písmeno, číslice, podtržítko nebo apostrof (například n_2')
• názvy jsou case-sensitive, velikost prvního písmena mění význam:
  • velké: typové konstruktory, třídy a datové konstruktory
  • malé: typové proměnné, funkce a konstanty
• operátory jsou vždy tvořeny maximální posloupností nealfabetických znaků, operátory které jsou konstruktory musí začínat dvojtečkou (například 3*-2 selže na nedefinovaném *-)

Definice funkcí a konstant

• definice konstant: vzor = výraz definuje všechny názvy obsažené ve vzoru
• definice n-ární funkce: jméno vzor₁… vzor_n = výraz

• definice se strážemi:
  jméno vzor₁ … vzor_n
  | stráž₁ = výraz₁
  | …
  | stráž_m = výraz_m

• definice pomocných funkcí a konstant po jejich použití:
  definice_funkce where
  definice_pomocné_funkce₁
  …
  definice_pomocné_funkce_m
  where lze použít jen při top-level definici nebo za case, pomocné definice jsou společné pro všechny větve se strážemi a mohou být vzájemně rekurzivní

• definice pomocných funkcí a konstant před jejich použitím:
  let
  definice_pomocné_funkce₁
  …
  definice_pomocné_funkce_m
  in výraz
  let výraz lze použít místo libovolného výrazu, pomocné definice mohou být vzájemně rekurzivní

• definice anonymní funkce (λ-funkce) je výraz \ vzor₁ … vzor_n -> výraz, například

  squareList l = map (\x -> x*x) l

Stráže (guards)

• každá stráž v definicích funkcí nebo case-výrazech je seznam oddělený čárkami, pro úspěch musí uspět každá položka seznamu
• každá položka je jedno z:
  • boolský výraz – nejčastější varianta, uspěje při vyhodnocení na True
  • let-deklarace (bez in) – zavede lokální funkci, uspěje vždy
  • vzor <- výraz (od Haskell 2010) – vyhodnotí výraz a zkusí výsledek navázat na vzor (zpřístupňuje nová jména)

Vzory (patterns)

• název naváže (match) cokoliv a zpřístupní pod tímto názvem, žádný název se nesmí v jednom vzoru opakovat (není unifikace)
• _ (podtržítko) jen naváže cokoliv
• literál naváže jen shodnou hodnotu, například 12.3 nebo "text"
• název@vzor je jako vzor ale navíc zpřístupní celek pod novým názvem
• Konstruktor vzor₁ … vzor_n naváže hodnotu vytvořenou daným n-árním konstruktorem, navíc se musí navázat jeho parametry na dané vzory.
  • funguje i pro nulární konstruktory, například True
  • seznamy mají speciální konstruktory [] a vzor_hlava:vzor_tělo a [vzor₁,…,vzor_k]
  • k-tice mají speciální konstruktor (vzor₁,…,vzor_k)
  • vzory lze vnořovat do sebe, například (True:_):dalsi je splněn jen pokud první prvek prvního seznamu je True
• vzor Kons {} uspěje na hodnotách zkonstruovaných n-árním konstruktorem Kons, podobně také záznamové vzory
• ~vzor (líný vzor) uspěje vždy a zkouší vázat až v okamžiku použití názvů definovaných vzorem (při selhání vyvolá výjimku, typicky chceme použít něco jiného)
• aritmetické n+k vzory byly v Haskellu 2010 odstraněny (nepoužívat)

Podmíněné výrazy

• if vytváří obyčejný výraz a musí vždy obsahovat stejně otypované větve: if bool_výraz then výraz else výraz
• case je vícecestný if s vázáním výsledku jednoho výrazu na různé vzory:
  case výraz of
  vzor₁ -> výraz₁
  …
  vzor_m -> výraz_m
  Mezi vzor_i a -> může navíc být seznam stráží | stráž_i,1,… ,stráž_i,k, navíc lze použít where společné pro všechny větve.

Základní typy

• data Bool = False | True pro pravdivostní hodnoty
• Int a Integer pro omezená a neomezená celá čísla (v GHC má Int typicky velikost ukazatele na platformě a Integer je z knihovny GMP)
• Char pro unicode znaky, literály 'a' (viz funkce v Data.Char)
• [a] pro seznam prvků typu a
• type String = [Char] pro řetězce, literály "abcd"
• (a₁, …, a_k) pro k-tice kde i-tý člen má typ a_i
• void-typ (), který může mít jen jednu hodnotu () (je to 0-tice)
• Double a Float pro klasická IEEE-754 čísla

• přidání Nothing jako indikátor neůspěchu:

  data Maybe a = Nothing | Just a

Typové deklarace

• výraz :: typ je výraz se specifikovaným typem, například 1 + (1::Integer)
• lze také pro více funkcí/konstant najednou jméno₁, …, jméno_k :: typ
• deklarace může obsahovat kontext specifikující požadavky na třídy pro zmíněné typové proměnné, syntax jména :: kontext => typ kde kontext je ve tvaru (Třída₁ params₁,… ,Třída_k params_k) (závorky lze vynechat pokud k=1)
• typová specifikace může vypadat jako:
  • volná proměnná (začíná malým písmenem) za kterou lze dosadit libovolný typ společný pro všechny výskyty proměnné v dané typové specifikaci (typ musí splňovat kontext)
  • funkční typ typ_vstupu -> typ_výstupu, asociuje doprava – například a -> (b -> c) se závorkami i bez deklaruje typ funkce s dvěma parametry typů a a b a výsledkem typu c
  • parametrizovaný typový konstruktor Typ_kon Param₁ … Param_k kde Param_i je libovolná typová specifikace, například Maybe Int nebo (Char,Float,Float) nebo [Maybe a]

Definice typu

• typová synonyma pomocí type Typ_kon parametry = Specifikace_typu definují zaměnitelné typy (zkratky), například type String = [Char] nebo type MaybeSez a = [Maybe a] (type nemůže zavádět nové datové konstruktory)

• newtype definuje stejným způsobem jako type, akorát zavádí nový konstruktor a vzniká odlišný typ z hlediska typového systému – stejná reprezentace, ale nejdou zaměnit, například newtype Cislo = Cislo Int

  Velmi často se používá konvence: newtype Age = Age { unAge :: Int }

  což nám dává dvě vzájemně inverzní funkce pro konverzi

  Age   :: Int -> Age  
  unAge :: Age -> Int

  Výhoda newtype oproti použití data s jedním konstruktorem je ve výkonu. Norma zaručuje že změna je jen na úrovni typu při kompilaci, reprezentace obou typů je identická a tedy konverze mezi nimi je prázdná operace.

• úplně nový typ se definuje pomocí data Typ_kon typ_params = Dat_kon₁ Params₁ | … | Dat_kon_k Params_k, například data Maybe a = Nothing | Just a nebo data Obrazec bod = Cara bod bod | Trojuhelnik bod bod bod
  (zavedené datové konstruktory se chovají jako n_i-ární funkce)
• Params_i může vždy být jedno z:
  • posloupnost n_i typů oddělených mezerami (n_i ≥ 0) kde jednotlivé položky jsou identifikovány pozičně (typy lze definovat i rekurzivně)
  • záznam (record) tvaru { typ_dekl_i,1,… , typ_dekl_i,n } kde typ_dekl_n,i je tvaru jména :: typ

• data a newtype definice můžou na konci specifikovat seznam tříd pro které jsou automaticky vygenerovány instance, syntaxe je typ_def deriving (Třída₁,… , Třída_m), ale norma to zaručuje jen pro některé třídy: Eq, Ord, Enum, Bounded, Show, Read, Ix (závorky lze vynechat pokud m = 1)
• infixní typové a datové konstruktory, typové proměnné, nebo třídy – musí začínat znakem : (seznamová : je tedy speciální instancí tohoto pravidla)
• TODO:
  • anotace striktnosti (možná jinam, s bang patterns?)

Záznamy

• jména zavedená záznamovými konstruktory jsou globální funkce pro výběr položky, například definování

  data Barva = RGB {r,g,b :: Int} | CMY {c,m,y :: Int}

  odpovídá (mimo jiné) definici globálních parciálních funkcí r,g,b,c,m,y :: Barva -> Int. Příklad polymorfního typu pro binární stromy:

  data Strom l v = List l 
  	| Vrchol { levy, pravy :: Strom l v, hodnota :: v }

• nová hodnota lze zkonstruovat:
  • použitím konstruktoru jako funkce s pozičními parametry RGB, CMY :: Int -> Int -> Int -> Barva, například cerna = RGB 0 0 0
  • s použitím názvů: RGB {g=0, b=128}, nezmíněné položky dostanou hodnotu undefined
  • pozměněním existující hodnoty: modra = cerna {b=255}

• analogickou syntaxi lze používat jako vzory pro pattern matching, například CMY { c=0, m=mVal } se naváže pokud byla hodnota zkonstruována pomocí CMY, ve složce c je 0 a do lokálního mVal se uloží hodnota složky m

List comprehensions

• zápis [ výraz | spec₁, …, spec_k ] kde spec_i je vždy buď boolská stráž, let-deklarace, nebo generátor tvaru jméno_i <- sez_výraz_i
• ve výsledném seznamu jsou právě ty instance výraz kde proměnné jsou libovolně zvolené ze svých generujících seznamů a stráže jsou splněné
• existují různá rozšíření – paralelní generování (místo zip), SQL-like syntaxe

Operátory

• (operátor) je funkce, například (++) "abc" "def" == "abc" ++ "def"
• `funkce` je infixní operátor, například 10 `div` 3 == div 10 3
• parciální aplikace binárního operátoru má syntaxi (par₁ op) a (op par₁), například (`mod` 3) počítá modulo třemi a (10 /) dělí deset čímkoliv
• infixní operátory mají prioritu 0-9 a asociativitu která rozhoduje o závorkování při setkání operátorů se stejnou asociativitou (levá, pravá, žádná)
• deklarace fixity číslo op₁,… , op_k kde fixity je infixl nebo infixr nebo infix
• nejvyšší prioritu 10 má aplikace funkce, defaultní priorita je infixl 9
• prioritu lze definovat i pro infixní použití funkcí nebo datových konstruktorů: infixl 7 `div`, `mod`
• infixní konstruktory jsou právě operátory začínající dvojtečkou, seznamová : je speciální instance tohoto pravidla

Typové třídy

• typová třída odpovídá interface v objektově-orientovaném programování (ne třídě v OOP!), tedy specifikuje funkce které musí být definované na všech typech dané třídy
• definice třídy pomocí class Třída typ_prom where specifikace_funkcí kde specifikace může obsahovat
  • typové signatury využívající typovou proměnnou typ_prom
  • defaultní implementace definovaných funkcí (typicky využívající jiné funkce z té samé nebo nadřazené třídy)

  class Eq a where
  	(==), (/=) :: a -> a -> Bool
  	x /= y     =  not (x == y)
  	x == y     =  not (x /= y)

• funkce definované třídou jsou globální a fungují na libovolných typech dané třídy
• aby mohl být typ zařazen do třídy, je nutné definovat jeho instanci třídy pomocí instance Třída Typ where definice_funkcí

• definice třídy nebo instance může navíc obsahovat před názvem třídy kontext specifikující požadavky na třídy pro použitou typovou proměnnou (tím se vytváří acyklická hierarchie tříd)

  instance Eq a => Eq (Maybe a) where
  	Nothing == Nothing  =  True
  	Just x  == Just y   =  x == y
  	_ == _              =  False

• viz typové deklarace a definice: specifikace kontextu, automatická derivace instancí

• v praxi se často používají rozšíření pro víceparametrické třídy (více proměnných, například IArray a e), někdy dokonce se závislostmi mezi proměnnými – to dělá třídy silnější než podobné mechanismy z imperativních jazyků