Index

Keresés

Számok

Az itt szereplő entitások a Prelude modulban definiáltak.

Típusok

Int :: * -- korlátos egész szám (32 bites platformon –2147483648..2147483647)
Integer :: * -- egész szám
Rational :: * -- racionális szám
Float :: * -- egyszeres pontosságú lebegőpontos szám
Double :: * -- dupla pontosságú lebegőpontos szám

Típusosztályok

Integral   =  {Int, Integer}
Num        =  {Int, Integer, Rational, Float, Double}
Real       =  {Int, Integer, Rational, Float, Double}
Fractional =                {Rational, Float, Double}
RealFrac   =                {Rational, Float, Double}
Floating   =                          {Float, Double}
RealFloat  =                          {Float, Double}

Típusosztály hierarchia

TypeIndex42e12d624072be4cba0c94e761443455.png

Számliterálok

115 :: Num p => p -- decimális
0xAB :: Num p => p -- hexadecimális
0o776 :: Num p => p -- oktális
3.14 :: Fractional p => p -- tizedestört
2.2e-10 :: Fractional p => p -- tudományos jelölésmód

Konstansok

pi :: Floating a => a -- π = 3.14..

Konverziók

fromIntegral :: (Integral a, Num b) => a -> b -- egészből számba konvertálás
realToFrac :: (Real a, Fractional b) => a -> b -- valósból törtbe konvertálás

Kerekítések

truncate :: (RealFrac a, Integral b) => a -> b -- nulla felé kerekítés
round :: (RealFrac a, Integral b) => a -> b -- legközelebbihez kerekítés
ceiling :: (RealFrac a, Integral b) => a -> b -- felfele kerekítés
floor :: (RealFrac a, Integral b) => a -> b -- lefele kerekítés

Operátorok

(+) :: Num a => a -> a -> a -- összeadás
(*) :: Num a => a -> a -> a -- szorzás
(-) :: Num a => a -> a -> a -- kivonás
negate :: Num a => a -> a -- negálás, '-' jellel is jelölhető
(/) :: Fractional a => a -> a -> a -- osztás
(^) :: (Integral b, Num a) => a -> b -> a -- pozitív egész kitevős hatványozás
(^^) :: (Fractional a, Integral b) => a -> b -> a -- egész kitevős hatványozás
(**) :: Floating a => a -> a -> a -- valós kitevős hatványozás

Függvények

abs :: Num a => a -> a -- abszolút érték
sqrt :: Floating a => a -> a -- négyzetgyök
log :: Floating a => a -> a -- e alapú logaritmus
exp :: Floating a => a -> a -- e hatványára emelés
sin :: Floating a => a -> a -- szinusz
cos :: Floating a => a -> a -- koszinusz
tan :: Floating a => a -> a -- tangens
asin :: Floating a => a -> a -- arkuszszinusz
acos :: Floating a => a -> a -- arkuszkoszinusz
atan :: Floating a => a -> a -- arkusztangens
sinh :: Floating a => a -> a -- hiperbolikus szinusz
cosh :: Floating a => a -> a -- hiperbolikus koszinusz
tanh :: Floating a => a -> a -- hiperbolikus tangens
asinh :: Floating a => a -> a -- hiperbolikus arkuszszinusz
acosh :: Floating a => a -> a -- hiperbolikus arkuszkoszinusz
atanh :: Floating a => a -> a -- hiperbolikus arkusztangens
quot :: Integral a => a -> a -> a -- maradékos osztás (multiplikatív)
div :: Integral a => a -> a -> a -- maradékos osztás (additív)
rem :: Integral a => a -> a -> a -- maradékképzés (multiplikatív)
mod :: Integral a => a -> a -> a -- maradékképzés (additív)
gcd :: Integral a => a -> a -> a -- legnagyobb közös osztó

Operátorok kötési erősségei

infixr 8  ^, ^^, **
infixl 7  *, /, `rem`, `mod`, `div`, `quot`
infixl 6  -, +, `negate`

Kipróbálom!

Test>
179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216 :: Integer

Logikai értékek, összehasonlítások

Az itt szereplő entitások a Prelude modulban definiáltak.

Típusok

Bool :: * -- logikai érték
Ordering :: * -- összehasonlítás eredménye

Típusosztályok

Eq   = {Int, Double, Char, ...}   -- egyenlőségvizsgálat
Ord  = {Int, Double, Char, ...}   -- összehasonlítás

Konstansok

True :: Bool -- igaz
otherwise :: Bool -- ugyanaz mint True
False :: Bool -- hamis
GT :: Ordering -- nagyobb
LT :: Ordering -- kisebb
EQ :: Ordering -- egyenlő

Logikai összekötők

(&&) :: Bool -> Bool -> Bool -- logikai ÉS
(||) :: Bool -> Bool -> Bool -- logikai VAGY
not :: Bool -> Bool -- tagadás

Operátorok

infix  4  ==, /=, <, >, <=, >=
infixr 3  &&
infixr 2  ||
(==) :: Eq a => a -> a -> Bool -- egyenlő-e
(/=) :: Eq a => a -> a -> Bool -- nem egyenlő-e
(<) :: Ord a => a -> a -> Bool -- kisebb-e
(>) :: Ord a => a -> a -> Bool -- nagyobb-e
(<=) :: Ord a => a -> a -> Bool -- kisebb vagy egyenlő-e
(>=) :: Ord a => a -> a -> Bool -- nagyobb vagy egyenlő-e

Függvények

compare :: Ord a => a -> a -> Ordering -- összehasonlítás
even :: Integral a => a -> Bool -- páros-e
odd :: Integral a => a -> Bool -- páratlan-e
min :: Ord a => a -> a -> a -- két érték minimuma
max :: Ord a => a -> a -> a -- két érték maximuma

Kipróbálom!

Test>
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 :: Integer

N-esek

Az itt szereplő entitások a Prelude modulban definiáltak.

Típusok

(,) :: * -> * -> * -- pár típuskonstruktor, használat: (,) Int Char vagy (Int,Char)
(,,) :: * -> * -> * -> * -- hármas típuskonstruktor
(,,,) :: * -> * -> * -> * -> * -- négyes típuskonstruktor

Függvények

(,) :: a -> b -> (a, b) -- pár konstruktor, használat: (,) 1 2 vagy (1,2)
(,,) :: a -> b -> c -> (a, b, c) -- hármas konstruktor, használat: (,,) 1 2 3 vagy (1,2,3)
(,,,) :: a -> b -> c -> d -> (a, b, c, d) -- négyes konstruktor, használat: (,,,) 1 2 3 4 vagy (1,2,3,4)
fst :: (a, b) -> a -- pár első eleme (first)
snd :: (a, b) -> b -- pár második eleme (second)

Kipróbálom!

Test>
(1, True) :: (Integer, Bool)

Listák

Az itt szereplő entitások a Prelude vagy a Data.List modulban definiáltak.

Típus

[] :: * -> * -- lista típuskonstruktor, használat: [] Int vagy [Int]

Konkrét lista példák

[] :: [a] -- üres lista
[1] :: Num a => [a] -- egy elemű lista
[True,False] :: [Bool] -- két elemű lista
[[1],[],[2+1,4]] :: Num a => [[a]] -- három elemű lista

Listafüggvények

infixr 5  :, ++
(:) :: a -> [a] -> [a] -- elem lista elejére fűzése
(++) :: [a] -> [a] -> [a] -- két lista összefűzése
concat :: Foldable t => t [a] -> [a] -- sok lista összefűzése
reverse :: [a] -> [a] -- listaelemek megfordítása
head :: [a] -> a -- lista első eleme
last :: [a] -> a -- lista utolsó eleme
init :: [a] -> [a] -- lista eleje (elemek az utolsót kivéve)
tail :: [a] -> [a] -- lista vége (elemek az elsőt kivéve)
inits :: [a] -> [[a]] -- lista összes eleje
tails :: [a] -> [[a]] -- lista összes vége
repeat :: a -> [a] -- elemismétlés végtelenszer

Listafüggvények Int-tel

infixl 9  !!
(!!) :: [a] -> Int -> a -- lista n-edik eleme, 0-tól számozva
length :: [a] -> Int -- lista hossza
take :: Int -> [a] -> [a] -- lista első n eleme
drop :: Int -> [a] -> [a] -- lista elemei kivéve az első n-et
splitAt :: Int -> [a] -> ([a], [a]) -- lista kettévágása az n-edik elemnél
replicate :: Int -> a -> [a] -- elemismétlés n-szer

Listafüggvények logikai értékekkel

null :: Foldable t => t a -> Bool -- üres-e a lista?
and :: Foldable t => t Bool -> Bool -- logikai ÉS több értéken
or :: Foldable t => t Bool -> Bool -- logikai VAGY több értéken

Listafüggvények számokkal

sum :: (Foldable t, Num a) => t a -> a -- számlista összegzése
product :: (Foldable t, Num a) => t a -> a -- számlista összeszorzása

Listafüggvények n-esekkel

zip :: [a] -> [b] -> [(a, b)] -- listaelemek párosítása (cipzározás)
unzip :: [(a, b)] -> ([a], [b]) -- párlista szétbontása (szétcipzározás)

Listafüggvények egyenlőségvizsgálattal

elem :: (Foldable t, Eq a) => a -> t a -> Bool -- eleme-e
delete :: Eq a => a -> [a] -> [a] -- elem első előfordulásának törlése
nub :: Eq a => [a] -> [a] -- ismétlődő elemek elhagyása
group :: Eq a => [a] -> [[a]] -- egymás melletti egyenlő elemek csoportba foglalása
isPrefixOf :: Eq a => [a] -> [a] -> Bool -- eleje-e egyik lista a másiknak

Listafüggvények összehasonlítással

minimum :: (Foldable t, Ord a) => t a -> a -- sok elem minimuma
maximum :: (Foldable t, Ord a) => t a -> a -- sok elem maximuma
insert :: Ord a => a -> [a] -> [a] -- elem beszúrása növekvően rendezett listába
sort :: Ord a => [a] -> [a] -- listaelemek növekvő sorrendbe rendezése

Kipróbálom!

Test>
[[1, 1, 1], [2], [3], [6, 6]] :: [[Integer]]

Karakterek

Az itt szereplő entitások a Prelude vagy a Data.Char modulban definiáltak.

Típus

Char :: * -- unikód karakterek

Karakter literálok

' ' :: Char -- szóköz
'\n' :: Char -- sortörés
'\'' :: Char -- egyszeres idézőjel
'\0' :: Char -- 0 kódú karakter
'a' :: Char -- latin betű
'ő' :: Char -- ékezetes betű
'π' :: Char -- görög betű
'≤' :: Char -- szimbólum

Függvények

isSpace :: Char -> Bool -- térköz-e
isAlpha :: Char -> Bool -- betű-e
isDigit :: Char -> Bool -- számjegy-e
isUpper :: Char -> Bool -- nagybetű-e
isLower :: Char -> Bool -- kisbetű-e
toUpper :: Char -> Char -- nagybetűvé alakítás
toLower :: Char -> Char -- kisbetűvé alakítás
digitToInt :: Char -> Int -- számjegy számmá alakítása
intToDigit :: Int -> Char -- szám számjeggyé alakítása
ord :: Char -> Int -- karakter unikód kódja
chr :: Int -> Char -- adott unikód kódú karakter

Kipróbálom!

Test>
'd' :: Char

Szövegek

Az itt szereplő entitások a Prelude modulban definiáltak.

Típus

String = [Char] – szövegek (karakterlisták)

Típusosztály

Show  = {...}   -- szöveggé alakítható típusok

Szövegliterálok

"" :: [Char] -- üres szöveg
"Hi\n" :: [Char] -- ugyanaz mint ['H','i','\n']

Függvények

show :: Show a => a -> String -- szöveggé alakítás
words :: String -> [String] -- szavakra bontás térközök mentén
unwords :: [String] -> String -- szavak összefűzése szóközzel
lines :: String -> [String] -- sorokra bontás
unlines :: [String] -> String -- sorok összefűzése (sortöréssel)

Kipróbálom!

Test>
["There", "are", "five", "words", "here."] :: [String]

Felsorolások

Az itt szereplő entitások a Prelude modulban definiáltak.

Típusosztály

Enum = {Int, Integer, Rational, Float, Double, Char, Bool}

Pontpont kifejezések

enumFromThen :: Enum a => a -> a -> [a] -- számtani sorozat
enumFrom :: Enum a => a -> [a] -- egyesével növekvő számtani sorozat
enumFromThenTo :: Enum a => a -> a -> a -> [a] -- korlátos számtani sorozat
enumFromTo :: Enum a => a -> a -> [a] -- egyesével növekvő korlátos számtani sorozat

Szintaxis

[1,3..]    = enumFromThen 1 3
[1..]      = enumFrom 1
[1,3..100] = enumFromThenTo 1 3 100
[1..100]   = enumFromTo 1 100

Konverziós függvények

fromEnum :: Enum a => a -> Int -- a felsorolható típus elemének indexe
toEnum :: Enum a => Int -> a -- a felsorolható típus n-edik eleme

Kipróbálom!

Test>
'a' :: Char

Magasabbrendű függvények

Az itt szereplő entitások a Prelude vagy a Data.Function modulban definiáltak.

infixr 9  .
infixr 0  $
id :: a -> a -- identikus függvény
const :: a -> b -> a -- konstans függvény képzése
($) :: (a -> b) -> a -> b -- függvényalkalmazás
(.) :: (b -> c) -> (a -> b) -> a -> c -- függvénykompozíció
curry :: ((a, b) -> c) -> a -> b -> c -- körrizés
uncurry :: (a -> b -> c) -> (a, b) -> c -- visszafele körrizés
flip :: (a -> b -> c) -> b -> a -> c -- kétparaméteres függvény paramétereinek megfordítása
on :: (b -> b -> c) -> (a -> b) -> a -> a -> c -- bináris operátor képzés

Listafüggvények

any :: Foldable t => (a -> Bool) -> t a -> Bool -- létezik-e adott tulajdonságú elem
all :: Foldable t => (a -> Bool) -> t a -> Bool -- minden elemre igaz-e
filter :: (a -> Bool) -> [a] -> [a] -- elemválogatás
partition :: (a -> Bool) -> [a] -> ([a], [a]) -- elemek szétválogatása
takeWhile :: (a -> Bool) -> [a] -> [a] -- adott tulajdonságú legnagyobb kezdőszelet
dropWhile :: (a -> Bool) -> [a] -> [a] -- adott tulajdonságú elemek kihagyása elölről
span :: (a -> Bool) -> [a] -> ([a], [a]) -- takeWhile és dropWhile egyben
map :: (a -> b) -> [a] -> [b] -- elemenkénti feldolgozás
iterate :: (a -> a) -> a -> [a] -- függvény iterálása kezdőelemre
until :: (a -> Bool) -> (a -> a) -> a -> a -- hátul tesztelő ciklus

Általánosított függvények

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] -- cipzározás függvénnyel
groupBy :: (a -> a -> Bool) -> [a] -> [[a]] -- csoportosítás adott ekvivalenciával
maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a -- legnagyobb elem adott rendezés szerint
minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a -- legkisebb elem adott rendezés szerint
sortBy :: (a -> a -> Ordering) -> [a] -> [a] -- rendezés adott rendezési reláció szerint

Hajtogatások

foldl1 :: Foldable t => (a -> a -> a) -> t a -> a -- hajtogatás balról
scanl1 :: (a -> a -> a) -> [a] -> [a] -- hajtogatás balról részeredményekkel
foldr1 :: Foldable t => (a -> a -> a) -> t a -> a -- hajtogatás jobbról
scanr1 :: (a -> a -> a) -> [a] -> [a] -- hajtogatás jobbról részeredményekkel
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b -- hajtogatás b. kezdőelemmel
foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b -- szigorú hajtogatás b. kezdőelemmel
scanl :: (b -> a -> b) -> b -> [a] -> [b] -- hajtogatás b. kezdőelemmel és részeredményekkel
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b -- hajtogatás j. kezdőelemmel
scanr :: (a -> b -> b) -> b -> [a] -> [b] -- hajtogatás j. kezdőelemmel és részeredményekkel

Kipróbálom!

Test>
["fa", "alma", "körte", "virág"] :: [[Char]]

Talán-értékek

Az itt szereplő entitások a Prelude vagy a Data.Maybe modulban definiáltak.

Típus:

Maybe :: * -> * -- legfeljebb 1 elemű lista

Függvények:

Just :: a -> Maybe a -- 1 elemű lista
Nothing :: Maybe a -- üreslista
isJust :: Maybe a -> Bool -- van-e elem
isNothing :: Maybe a -> Bool -- üres-e
maybe :: b -> (a -> b) -> Maybe a -> b -- feldolgozás alapértelmezett értékkel
find :: Foldable t => (a -> Bool) -> t a -> Maybe a -- első adott tulajdonságú elem keresése
lookup :: Eq a => a -> [(a, b)] -> Maybe b -- elem keresése asszociációs listában

Kipróbálom!

Test>
Just 4 :: Maybe Integer

Diszjunkt unió

Az itt szereplő entitások a Prelude modulban definiáltak.

Típus:

Either :: * -> * -> * -- diszjunkt unió típuskonstruktor

Függvények:

Left :: a -> Either a b -- elem adása az első halmazból
Right :: b -> Either a b -- elem adása a második halmazból
either :: (a -> c) -> (b -> c) -> Either a b -> c -- diszjunkt unióbeli elem feldolgozása

Kipróbálom!

Test>
["könyv", "füzet"] :: [[Char]]

Hibakezelés

undefined :: a -- számítás megszakítása
error :: [Char] -> a -- számítás megszakítása hibaüzenettel

Egyéb nyelvi elemek

Feltételes kifejezés

Test>
"nem osztható" :: [Char]

Halmazkifejezések

Test>
Test>
Test>
Test>
Test>

Kötési erősség összefoglaló

A Prelude-beli operátorok kötési erősségei:

infixr 9  !!, .
infixr 8  ^, ^^, **
infixl 7  *, /, `rem`, `mod`, `div`, `quot`
infixl 6  -, +, `negate`
infixr 5  :, ++
infix  4  ==, /=, <, >, <=, >=
infixr 3  &&
infixr 2  ||
infixr 0  $

Ábrák

A következő entitások nem szerepelnek a Haskell Platform moduljaiban.

Típusok

Diagram :: * -- ábra
Color :: * -- szín

Alapelemek

(>-<) :: Point -> Point -> Diagram -- két végponttal adott szakasz
circle :: Double -> Diagram -- adott sugarú kör
rect :: Double -> Double -> Diagram -- adott szélességű és magasságú téglalap
polygon :: [Point] -> Diagram -- adott csúcsokkal előállított poligon
polyline :: [Point] -> Diagram -- adott csúcsokon átmenő töröttvonal

Összekötők

(<|>) :: Diagram -> Diagram -> Diagram -- két ábra egymásra helyezése
union :: [Diagram] -> Diagram -- sok ábra egymásra helyezése

Transzformációk

move :: Diagram -> Point -> Diagram -- eltolás
rotate :: Diagram -> Double -> Diagram -- origó körüli forgatás (fokban mérve pozitív irányban)
scale :: Diagram -> Double -> Diagram -- origóból történő nagyítás/kicsinyítés
clip :: Point -> Point -> Diagram -> Diagram -- vágás (bal alsó és jobb felső sarkok); képméret beállítás

Stílus

fill :: Diagram -> Color -> Diagram -- ábra kitöltése színnel
stroke :: Diagram -> Color -> Diagram -- vonalszín beállítás
strokeWidth :: Diagram -> Double -> Diagram -- vonalvastagság beállítás

Színek

color :: String -> Color -- adott nevű szín (angol névvel)
rgb :: Double -> Double -> Double -> Color -- RGB összetevőkből előállított szín

Előre definiált szín konstansok

black :: Color -- fekete, rgb 0 0 0
gray :: Color -- szürke, rgb 0.5 0.5 0.5
white :: Color -- fehér, rgb 1 1 1
red :: Color -- piros, rgb 1 0 0
green :: Color -- zöld, rgb 0 0.5 0
blue :: Color -- kék, rgb 0 0 1
yellow :: Color -- sárga, rgb 1 1 0

Szövegek és linkek

textFrom :: String -> Point -> Diagram -- szöveg adott pozíciótól
textTo :: String -> Point -> Diagram -- szöveg adott pozícióig
textAt :: String -> Point -> Diagram -- szöveg adott pozíciónál
fontFamily :: Diagram -> String -> Diagram -- betűkészlet megadás
link :: Diagram -> String -> Diagram -- html link megadása

Operátorok kötési erősségei

infix  4  >-<
infixl 3  `move`, `rotate`, `scale`, `fill`
infixl 3  `textFrom`, `textTo`, `fontFamily`, `link`
infixl 2  <|>

Kipróbálom!

Test>