Ugrás a tartalomhoz

Haskell

A Wikiszótárból, a nyitott szótárból

Angol


Főnév

Haskell (tsz. Haskells)

  1. (informatika) Haskell nyelv

A Haskell egy deklaratív, tisztán funkcionális programozási nyelv, amelyet főként akadémiai és kutatási célokra fejlesztettek ki, de gyakorlati alkalmazásokban is megtalálható (pl. pénzügyi rendszerekben, fordítóprogramokban, eszközláncokban).

Haskell célja: modern, elegáns, matematikailag megalapozott programozási modell biztosítása.


1️⃣ Alapok

  • Első kiadás: 1990
  • Elnevezés: Haskell Curry, logikus és matematikus nevéből.
  • Fő paradigma: pure functional = tisztán funkcionális → nincsenek mellékhatások.
  • Típusok: statikus (kompiláláskor ellenőrzött), erős típusosság
  • Típusinferencia: automatikus → sokszor nem kell típusokat kiírni.
  • Lustaság (lazy evaluation): értékelés csak akkor történik, ha szükséges → végtelen adatszerkezetek is létrehozhatók.


2️⃣ Funkcionális programozás

A funkcionális programozásban a függvények az elsőrendű polgárok:

  • Függvényt át lehet adni paraméterként.
  • Függvény lehet visszatérési érték.
  • Függvényt lehet komponálni más függvényekkel.

Haskellben minden kifejezés értéket ad vissza. Nem “utasításokat” írunk, hanem kifejezésekből építjük fel a programot.


3️⃣ Egyszerű példa

double x = x * 2

main = print (double 5)
-- Kimenet: 10
  • double egy függvény.
  • A main a program belépési pontja.
  • print kiír a standard kimenetre.


4️⃣ Tisztán funkcionális

  • Nincsenek mellékhatások: egy függvény ugyanarra a bemenetre mindig ugyanazt az eredményt adja.
  • Példa:
square x = x * x

A square 4 mindig 16-ot ad vissza.


5️⃣ Lazy evaluation

A Haskell lustán kiértékelő nyelv:

take 5 [1..] 
-- Eredmény: [1,2,3,4,5]

[1..] egy végtelen lista, de a take csak az első 5 elemet kérdezi le → a többit sosem értékeljük ki.


6️⃣ Típusok és típusinferencia

Haskellben minden kifejezésnek van típusa.

square :: Int -> Int
square x = x * x

A :: jelzi a típust:

  • Int -> Int jelentése: Int típusú bemenet → Int típusú eredmény.

Típusinferencia:

double x = x * 2

Itt nem írtunk ki típust, de a fordító kitalálja, hogy Num a => a -> a.


7️⃣ Mintaillesztés (pattern matching)

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

Itt a factorial függvény több definícióval rendelkezik → a bemenet mintája alapján választ.


8️⃣ Rekurzió

Haskellben a rekurzió a ciklusok alternatívája, mivel nincs hagyományos for vagy while.

sumList [] = 0
sumList (x:xs) = x + sumList xs
  • Üres lista ([]) → eredmény 0.
  • (x:xs) szintaktika: fej és farok.


9️⃣ List comprehension (ismerős lehet Pythonból!)

[x^2 | x <- [1..5]]
-- Eredmény: [1,4,9,16,25]

Olvasata: “x vegyen fel értékeket az [1..5] listából, és ezek négyzetét gyűjtsük össze”.

Szűrőfeltétellel:

[x | x <- [1..10], even x]
-- Eredmény: [2,4,6,8,10]

10️⃣ Higher-order functions

A függvények is paraméterként átadhatók más függvényeknek.

Példa:

map square [1,2,3,4]
-- Eredmény: [1,4,9,16]

A map függvény minden listaelemre alkalmazza a square függvényt.


11️⃣ Lambdafüggvények

Névtelen, inline definiált függvény:

map (\x -> x + 1) [1,2,3]
-- Eredmény: [2,3,4]

\x -> x + 1 egy lambda.


12️⃣ Currying

Minden függvény egy paramétert fogad, és ha több paraméter van, részleges alkalmazás történik:

add x y = x + y

add5 = add 5
add5 3
-- Eredmény: 8

Az add 5 egy új függvény, ami 5-höz ad egy számot.


13️⃣ Monádok (röviden)

Monádok olyan szerkezetek, amelyek lehetővé teszik:

  • a mellékhatások kezelését (IO, állapot, hibakezelés stb.)
  • például: IO, Maybe, Either, List.

IO példa:

main = do
    putStrLn "Add meg a neved:"
    name <- getLine
    putStrLn ("Hello, " ++ name ++ "!")

A do blokk lehetővé teszi a szekvenciális műveletek írását.


14️⃣ Maybe

Null biztonságos műveletekhez használható.

safeDiv _ 0 = Nothing
safeDiv x y = Just (x `div` y)

Használat:

case safeDiv 10 2 of
    Nothing -> putStrLn "Hiba!"
    Just result -> print result

15️⃣ Típusosztályok (type classes)

Polimorf viselkedést adnak típusoknak.

Példa:

class Eq a where
    (==) :: a -> a -> Bool
    (/=) :: a -> a -> Bool

Minden Eq típusú dologhoz definiálni kell == és /=.

Beépített példák:

  • Eq → egyenlőség
  • Ord → rendezés
  • Show → sztringgé alakítás
  • Read → sztringből olvasás
  • Num → számok műveletei


16️⃣ Végtelen adatszerkezetek

A lustaság miatt akár végtelen listák is használhatók:

naturals = [0..]
take 10 naturals
-- Eredmény: [0,1,2,3,4,5,6,7,8,9]

17️⃣ Haskell ökoszisztéma

  • GHC: a legelterjedtebb Haskell fordító (Glasgow Haskell Compiler).
  • Cabal, Stack: build rendszer és csomagkezelő.
  • Hackage: a Haskell csomagtára.
  • Lens, Conduit, Persistent: haladó könyvtárak.


18️⃣ Előnyök

✅ Erősen típusos → kevés runtime hiba ✅ Lustaság → hatékony memóriahasználat, végtelen szerkezetek ✅ Rövid, kifejező kód ✅ Magas szintű absztrakciók ✅ Könnyű párhuzamosítás


19️⃣ Hátrányok

⚠️ Tanulási görbe → eltér az imperatív gondolkodástól ⚠️ Nincs annyi ipari támogatás, mint pl. C++, Java esetén ⚠️ A monádok megértése kezdetben nehéz lehet


20️⃣ Összefoglalás

A Haskell nem mainstream, de rendkívül erős és elegáns nyelv, amely:

  • Matematikai alapú.
  • Biztonságos (kompiláláskor sok hibát kizár).
  • Magas szintű kifejezést tesz lehetővé.
  • Tisztán funkcionális → sok párhuzamos alkalmazásban ideális.

Alkalmazási területek:

  • fordítóprogramok
  • pénzügyi modellezés
  • tudományos kutatás
  • prototípus-készítés
  • tanulás/funkcionális szemlélet fejlesztése

További információk

A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=Haskell&oldid=3503620”