Хаскелл Карри

История

  • 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]
Made with Slides.com