Хаскелл Карри
История
- 1958 - первый функциональный язык программирования — Lisp
- 1987 - комитет для разработки открытого стандарта
- 1990 - первая стандартизированная версия
Декларативное программирование
-
функции высших порядков
- чистые функции
- хвостовая рекурсия
- ленивые вычисления
- иммутабельные структуры данных
Haskell
-
чистый функциональный язык программирования
- статически типизированный
- с системой вывода типов
- ленивый
- со списковым включением
Литералы
ghci> 2 + 15
17
ghci> 49 * 100
4900
ghci> 1892 - 1472
420
ghci> 5 / 2
2.5
ghci> (50 * 100) - 4999
1
ghci> 50 * 100 - 4999
1
ghci> 50 * (100 - 4999)
-244950
Литералы
ghci> True && False
False
ghci> not False
True
ghci> not (True && True)
False
ghci> 5 == 5
True
ghci> 1 == 0
False
ghci> 5 /= 5
False
ghci> 5 /= 4
True
ghci> "hello" == "hello"
True
Литералы
ghci> 2 == "two"
No instance for (Num [Char]) arising from the literal `2'
In the first argument of `(==)', namely `2'
In the expression: 2 == "two"
In an equation for `it': it = 2 == "two"
Функции
doubleMe x = x + x
ghci> doubleMe 9
18
ghci> doubleMe 8.3
16.6
doubleUs x y = doubleMe x + doubleMe y
ghci> doubleUs 2.3 34.2
73.0
Функции
doubleSmallNumber x = if x > 100
then x
else x*2
Функции
lucky :: (Integral a) => a -> String
lucky 7 = "LUCKY NUMBER SEVEN!"
lucky x = "Sorry, you're out of luck, pal!"
factorial :: (Integral a) => a -> a
factorial 0 = 1
factorial n = n * factorial (n - 1)
Массивы
ghci> [1,2,3,4] ++ [9,10,11,12]
[1,2,3,4,9,10,11,12]
ghci> "hello" ++ " " ++ "world"
"hello world"
ghci> ['w','o'] ++ ['o','t']
"woot"
ghci> let a = [1, '2']
No instance for (Num Char) arising from the literal `1'
In the expression: 1
In the expression: [1, '2']
In an equation for `a': a = [1, '2']
Массивы
ghci> [1,2,3,4] ++ [9,10,11,12]
[1,2,3,4,9,10,11,12]
ghci> "hello" ++ " " ++ "world"
"hello world"
ghci> 'w':'o':['o','t']
"woot"
ghci> let b = [[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3]]
ghci> b ++ [[1,1,1,1]]
[[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3],[1,1,1,1]]
Массивы
ghci> [3,2,1] > [2,1,0]
True
ghci> [3,2,1] > [2,10,100]
True
ghci> [3,4,2] > [3,4]
True
ghci> [3,4,2] > [2,4]
True
ghci> [3,4,2] == [3,4,2]
True
Массивы
Массивы
ghci> [1..20]
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
ghci> ['a'..'z']
"abcdefghijklmnopqrstuvwxyz"
ghci> ['K'..'Z']
"KLMNOPQRSTUVWXYZ"
ghci> [2,4..20]
[2,4,6,8,10,12,14,16,18,20]
ghci> [3,6..20]
[3,6,9,12,15,18]
ghci> [0.1, 0.3 .. 1]
[0.1,0.3,0.5,0.7,0.8999999999999999,1.0999999999999999]
ghci> take 10 (cycle [1,2,3])
[1,2,3,1,2,3,1,2,3,1]
Массивы
ghci> [x*2 | x <- [1..10]]
[2,4,6,8,10,12,14,16,18,20]
ghci> [x*2 | x <- [1..10], x*2 >= 12]
[12,14,16,18,20]
ghci> [ x | x <- [50..100], x `mod` 7 == 3]
[52,59,66,73,80,87,94]
ghci> [ x*y | x <- [2,5,10], y <- [8,10,11], x*y > 50]
[55,80,100,110]
Кортежи
ghci> (1,2)
(1,2)
ghci> (1, '2')
(1,'2')
Couldn't match expected type `(t, t1)'
against inferred type `(t2, t3, t4)'
In the expression: (8, 11, 5)
In the expression: [(1, 2), (8, 11, 5), (4, 5)]
In the definition of `it': it = [(1, 2), (8, 11, 5), (4, 5)]
ghci> let rightTriangles = [ (a,b,c) | c <- [1..10], b <- [1..c], a <- [1..b], a^2 + b^2 == c^2]
ghci> rightTriangles
[(3,4,5),(6,8,10)]
Типы
- Int -2147483648 .. 2147483647
- Integer - неограниченные числа
- Float
- Double
- Bool
- Char
Типы
ghci> :t 'a'
'a' :: Char
ghci> :t True
True :: Bool
ghci> :t "HELLO!"
"HELLO!" :: [Char]
ghci> :t (True, 'a')
(True, 'a') :: (Bool, Char)
ghci> :t 4 == 5
4 == 5 :: Bool
addThree :: Int -> Int -> Int -> Int
addThree x y z = x + y + z
Типы
ghci> :t head
head :: [a] -> a
ghci> :t (==)
(==) :: (Eq a) => a -> a -> Bool
Классы типов
- Eq - типы, поддерживающие проверку равенства (==, /=) - все типы, кроме функций
- Ord - типы, у которых есть порядковое сравнение (>, <, ...)
- Show - приводимые к строкам
Классы типов
- Enum - перечислимые - succ, pred ((), Bool, Char, Ordering, Int, Integer, Float, Double)
- Bounded - ограниченные (Int, Char, Bool, ())
- Num - числа
- Integral - целые числа
- Floating - Float, Double
Классы типов
ghci> :t (==)
(==) :: (Eq a) => a -> a -> Bool
ghci> :t (>)
(>) :: (Ord a) => a -> a -> Bool
ghci> :t show
show :: Show a => a -> String
Функции высшего порядка
multThree :: (Num a) => a -> a -> a -> a
multThree x y z = x * y * z
ghci> let multTwoWithNine = multThree 9
ghci> multTwoWithNine 2 3
54
ghci> let multWithEighteen = multTwoWithNine 2
ghci> multWithEighteen 10
180
Функции высшего порядка
applyTwice :: (a -> a) -> a -> a
applyTwice f x = f (f x)
ghci> applyTwice (+3) 10
16
ghci> applyTwice (++ " HAHA") "HEY"
"HEY HAHA HAHA"
ghci> applyTwice ("HAHA " ++) "HEY"
"HAHA HAHA HEY"
ghci> applyTwice (multThree 2 2) 9
144
ghci> applyTwice (3:) [1]
[3,3,1]
Функции высшего порядка
zipWith' :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith' _ [] _ = []
zipWith' _ _ [] = []
zipWith' f (x:xs) (y:ys) = f x y : zipWith' f xs ys
ghci> zipWith' (+) [4,2,5,6] [2,6,2,3]
[6,8,7,9]
ghci> zipWith' max [6,3,2,1] [7,3,1,5]
[7,3,2,5]
map :: (a -> b) -> [a] -> [b]
map _ [] = []
map f (x:xs) = f x : map f xs
ghci> map (+3) [1,5,3,1,6]
[4,8,6,4,9]
filter :: (a -> Bool) -> [a] -> [a]
filter _ [] = []
filter p (x:xs)
| p x = x : filter p xs
| otherwise = filter p xs
ghci> filter (>3) [1,5,3,2,1,6,4,3,2,1]
[5,6,4]
ghci> filter (==3) [1,2,3,4,5]
[3]
deck
By sashqa
deck
- 1,134