Języki programowania – Haskell

Języki programowania – Haskell
zadanie projektowe nr. 4 (2016/17)
T. Goluch
1. Kompilacja, uruchamianie i Hello world
Kompilacja i uruchamianie:
ghc --make hello.hs
./hello
Interaktywny interpreter:
ghci hello.hs
main = putStrLn "Hello world!"
Haskel w przeglądarce:
http://tryhaskell.org/
http://ideone.com/
2. Cechy języka
– wszystko jest funkcją
– funkcja składa się z deklaracji:
nazwa_funkcji::Kwalifikatory_Typu => Typ_Argumentu_1 -> Typ_Argumentu_2 ->
Typ_Wyniku
nazwa_funkcji argument_1 argument_2 = let definicje_podfunkcji in polecenie
zwracające wynik
– podstawowe typy danych (operator :: - czytamy jako: „jest typu”):
True::Bool,
'a'::Char,
1::Int,
1::Integer,
1.0::Double,
"abc"::String (tożsame z listą znaków [Char])
listy: 1:2:3:4:[], 1:2:[3, 4], [1, 2, 3, 4] lub [1, 2 .. 4] lub [1 .. 4]::[Int] – homogeniczne o zmiennej długości
krotki: (1, ‘a’, „litera”) – heterogeniczne o stałej długości
K. Turowski, T. Goluch
Języki programowania
{C91E19C4-8B08-4D63-9B7C-0913AAB2A7CE}
{C91E19C4-8B08-4D63-9B7C-0913AAB2A7CE}
1
– funkcje nie są redefiniowalne (w obrębie własnego zakresu) więc np.
x = 2
x = 3
main = print x
nie zadziała
– kolejność funkcji w pliku nie ma znaczenia
main = print x
x = 123
– leniwe wartościowanie - obliczenia są wykonywane TYLKO wtedy, gdy jest to niezbędne np.
podziel :: (RealFrac a) => a -> a -> a
podziel x y = let q = (/) x y in if (abs y) < 0.001 then 0 else q
– ukonkretnianie funkcji
odwroc :: (RealFrac a) => a -> a
odwroc = podziel 1
– składanie funkcji
identycznosc :: (RealFrac a) => a -> a
identycznosc = odwroc . odwroc
3. Silnia i wyrażenia: if … then … else, let…in, where oraz |
silnia :: (Num a, Ord a) => a -> a
silnia n = if n == 1 then 1 else n * silnia (n - 1)
silnia n = let loop n' a = if n' == 1 then a else loop (n' - 1) (a * n')
in loop n 1
silnia n = let loop n' a | n' == 1 = a
| otherwise = loop (n' - 1) (a * n')
in loop n 1
silnia n = loop n 1 where loop n' a | n' == 1 = a
| otherwise = loop (n' - 1) (a * n')
4. Listy, mapy i filtry
– moduł zawierający: import Data.List
– typowe funkcje: head, tail, last, init, reverse, take n
reverse::[a] -> [a]
reverse [] = []
reverse (x:y) = reverse y ++ [x]
– nieskończony ciąg Fibonacciego
fibonacci = 1:1:[(a + b) | (a, b) <- zip fibonacci (tail fibonacci)]
print fibonacci powoduje nieskończoną pętlę,
print (take 1000 fibonacci) działa – bo leniwe wartościowanie
– wykonanie funkcji f na wszystkich elementach listy x
map f x
[f xs | xs <- x]
np.
map cos [1..10]
K. Turowski, T. Goluch
Języki programowania
{C91E19C4-8B08-4D63-9B7C-0913AAB2A7CE}
{C91E19C4-8B08-4D63-9B7C-0913AAB2A7CE}
2
map (+1) [1..10]
map (\x -> 3 * x + 2) [1..10]
– wybranie tylko elementów funkcji f na wszystkich elementach listy x
filter f x
np.
filter (>3) [-10..10]
filter (\x -> x * x == 1) [-10..10]
– scalenie dwóch list w listę par (elementy dłuższej listy są odrzucane
zip a b
np.
zip "Mississippi" [-10..10]
5. Tablice1
– moduł zawierający: import Data.Array
– tworzenie tablicy sqr zawierającej kwadraty liczb od 1 do 100
array :: (Ix a) => (a,a) -> [(a,b)] -> Array a b
sqr = array (1,100) [(i, i*i) | i <- [1..100]]
– pobranie kwadratu liczby 7
sqr!7 => 49
– sprawdzenie zakresów wymiarów tablicy
bounds sqr => (1,100)
– rekurencyjne tworzenie tablicy zawierającej liczby Fibonacciego
fibs :: Int -> Array Int Int
fibs n = a where a = array (0,n) ([(0, 1), (1, 1)] ++
[(i, a!(i-2) + a!(i-1)) | i <- [2..n]])
– pobranie 10 elementu ciągu
fibs 10 ! 10 => 89
6. Tablice haszujące
– tworzenie tablicy H z przykładowej listy par
H :: Map Char Int
H = fromList [('a', 3), ('b', 5), ('c', 7)]
– wyszukiwanie elementu x w tablicy H
wynik :: Maybe a
wynik = lookup x H
7. Typy danych
– proste:
data Color = Red | Green | Blue
isRed :: Color -> Bool
isRed Red = True
isRed _ = False
main = print (isRed Blue)
1
https://www.haskell.org/tutorial/arrays.html
K. Turowski, T. Goluch
Języki programowania
{C91E19C4-8B08-4D63-9B7C-0913AAB2A7CE}
{C91E19C4-8B08-4D63-9B7C-0913AAB2A7CE}
3
– złożone:
data Chars = Value Char | Join Chars Chars
isChar :: Chars -> Bool
isChar (Value x) = True
isChar _ = False
toString :: Chars -> String
toString (Join x y) = (toString x) ++ (toString y)
toString (Value x) = [x]
main = print (toString (Join (Join (Value 'a') (Value 'b')) (Value 'c')))
8. Funkcje: group, sort
Funkcja group przyjmuje listę i zwraca listę składającą się z list zgrupowanych identycznych kolejnych elementów.
Przykładowo:
group :: Eq a => [a] -> [[a]]
group "Mississippi" = ["M","i","ss","i","ss","i","pp","i"]
Funkcja sort implementuje stabilną wersję algorytmu sortującego. Przykładowo:
sort :: Ord a => [a] -> [a]
sort "Mississippi" = "Miiiippssss"
Funkcje wymagają zaimportowania modułu Data.List
K. Turowski, T. Goluch
Języki programowania
{C91E19C4-8B08-4D63-9B7C-0913AAB2A7CE}
{C91E19C4-8B08-4D63-9B7C-0913AAB2A7CE}
4