Презентация на тему Средства функционального програмирования

формы записи уравнений
comp :: (b -> c)

comp :: (b -> c) -> (a -> b) -> a -> c
comp f g x = f (g x)

comp :: (b -> c) -> (a -> b) -> (a -> c)
comp = \f -> \g -> \x -> f (g x)

Все функции в Haskell – это функции с одним аргументом и одним результатом!

Haskell B. Curry – карринг.
«Карринговые» функции – это частично параметризуемые функции.

plus1 :: Integer -> Integer -> Integer -- в карринговой форме
plus1 x y = x + y

plus2 :: (Integer, Integer) -> Integer -- не в карринговой форме
plus2 (x, y) = x + y

curry plus2 => plus1
uncurry plus1 => plus2

curry :: ((a, b) -> c) -> a -> b -> c
uncurry :: (a -> b -> c) -> (a, b) -> c
curry f x y = f (x, y)
uncurry f (x, y) = f x y

( )
( )

:: (Num a) => a -> a -> a
(+)

raiseList :: (Num a) => [a] -> [a]
raiseList = map (1+)

lst

lst

(+) ? 8 -> \n->n+8
(+ 8)

searchList :: (Eq a) => a -> [a] -> Bool
searchList e = (foldr (||) False) . (map (== e))

searchList 5 [1,3,7,5,2]
((foldr (||) False) . (map (== 5))) [1,3,7,5,2]
foldr (||) False (map (== 5) [1,3,7,5,2])
foldr (||) False [1 == 5, 3 == 5, 7 == 5, 5 == 5, 2 == 5]
foldr (||) False [False, False, False, True, False]
True

раз о сортировке списка с помощью дерева
build ::

build = foldr insert Empty
flatten = foldTree (:) []

Фильтрация списка

filter :: (a -> Bool) -> [a] -> [a]
filter _ [] = []
filter f (x:ls) | f x = x : (filter f ls)
| otherwise = filter f ls

filter :: (a -> Bool) -> [a] -> [a]
filter f = foldr condCons []
where condCons x l = if f x then x:l else l

quicksort :: (Ord a) => [a] -> [a]
quicksort [] = []
quicksort (x:ls) = (quicksort (filter (< x) ls)) ++ [x] ++
(quicksort (filter (>= x) ls))

list

list

tree

tree

quicksort [] = []
quicksort (x:ls) = (quicksort [y | y<-ls, y < x]) ++ [x] ++
(quicksort [y | y<-ls, y >= x])

descartes ls1 ls2 = [(x, y) | x <- ls1, y <- ls2]
oddSqrs ls = [x*x | x <- ls, x `mod` 2 == 1]

функция множества
type IntSet = (Integer -> Bool)
empty ::

from2to100 :: IntSet
from2to100 e = (e >= 2) && (e <= 100)

odds :: IntSet
odds e = (e `mod` 2 == 1)

conj :: IntSet -> IntSet -> IntSet
(s1 `conj` s2) e = (s1 e) && (s2 e)

disj :: IntSet -> IntSet -> IntSet
(s1 `disj` s2) e = (s1 e) || (s2 e)

diff :: IntSet -> IntSet -> IntSet
(s1 `diff` s2) e = (s1 e) && ! (s2 e)

addElem :: Integer -> IntSet -> IntSet
addElem a s e = (e == a) || (s e)

remElem :: Integer -> IntSet -> IntSet
remElem a s e = (e <> a) && (s e)

fromSet :: IntSet -> [Integer] -> [Integer]
fromSet =

set ls

[x | x <- ls, set x]

filter