Д.з. презентация

= if (sqrt ((x-a)^2+(y-b)^2)) <= r)
then True
else False

sqrt →
(x-a)^2+(y-b)^2) <= r^2
if …условие… then True else False
→ …условие…
лишние скобки

Double Double Double

class Shape a where
area:: a -> Double
perim:: a -> Double
contains:: a -> Double -> Double -> Bool

instance Shape Circle where
contains (Circle r x0 y0) x y = (x-x0)^2+(y-y0)^2) <= r^2

instance Shape Rect where
contains (Rect w h x0 y0) x y = abs(x-x0)<=w/2 && abs(y-y0)<=h/2

… и определения area и perim …

b < Rat c d = a*c < b*d
--- Вспомните 6 класс!
Rat a b < Rat c d = if c*d > 0 then a*c < b*d else a*c > b*d

instance Eq Ration where
Rat a b == Rat c d = a*c == b*d

instance Num Ration where
Rat a b + Rat c d = Rat (a*c + b*d) (b*d)

instance Show Ration where
show (Rat a b) = show a ++ "/" ++ show b

area s * 10

В определении класса можно задавать правила
 В instance можно их переопределять

instance Shape Abc where
weight s = area s * area s

Полезное применение – связь < и > или == и /= и т.д.

class Ord
x < y = y > x
x > y = y < x

Abc = … deriving (Show, Ord, Eq)

См. также http://www.haskell.org/haskellwiki/Generics

C# или С++?

Инкапсуляция?
Несколько мешают конструкторы, с их помощью мы всегда можем посмотреть поля

Полиморфизм
Бывает статический и динамический
(Тут мы обсуждали, в чем разница…)
Списки не могут содержать элементы разных типов, даже если они экземпляры одного класса [Circle 1 2 6, Rect 6 9 2 8, Circle 10 0 0]
В Haskell так писать нельзя!
(Тут мы обсуждали, как это связано с полиморфизмом)
Но см. http://www.haskell.org/haskellwiki/Existential_types

→ 2
[1,2,3] → -1
-1 может быть и "хорошим" ответом

[1,2,3] → 267438658267829576524816584
На практике вполне хорошее решение
Или, современный вариант☺
[1,2,3] → 100500

Вернуть пару
[1,2,3,2] → (True, 2)
[1,2,3] → (False, 0)
Как сделать generic?? – не очень понятно

→ "2"
Неудобно..

[] или [x]
[1,2,3,2] -> [2]
[1,2,3] -> []
 
Список всех повторяющихся
[1,2,3,2,3] -> [2,3]
[1,2,3] -> []
Разве мы не будем делать лишнюю работу?
Ленивые вычисления!

Maybe a = Just a | Nothing

[1,2,3,2] -> Just 2
[1,2,3] -> Nothing

findSame [] = Nothing
findSame (x:xs) = if elem x xs then Just x
else findSame xs

– в качестве параметра будем передавать значение, которое надо возвращать при ошибке

Примеры
find (>0) xs (-1)
find odd xs 0
 
Определение
find f [] err = err
find f (x:xs) err = if f x then x
else find f xs err

это то, что надо сделать при ошибке

Пример:
Найти в xs число > 0 а если его нет, то найти число >0 в ys, а если и его нет, вернуть 0.

find (>0) xs
(find (>0) ys 0)
Так можно, потому что ленивые вычисления
Получается, что find не совсем функция, а что-то вроде оператора:
find условие список
код-который-надо-выполнить-если-не-нашли
Называется failure continuation (продолжение при ошибке)

первое число большее 500, а если и его нет, то первое число большее 100 (а если и его нет, вернуть 0):
find (>1000) xs
(find (>500) xs
(find (>100) 0)

=
find (==x) xs
(
findsame xs err
)

Небольшой фокус: Написали findSame без if
Потому что find – это тоже что-то вроде if
-----------------------------------------------------------
С другой стороны, сам по себе failure continuation вовсе не фокус, а вполне естественная функциональность
В вычислительных пакетах всегда было что-то похожее – например, при решении СЛУ передаем функцию, которую надо вызвать, если у системы нет решений

sin 2, cos 2, sin 3, cos 3]

superMap f [] = []
superMap f (x:xs) = f x ++ superMap f xs

Играет очень большую роль в Haskell
стандартная функция concatMap
стандартный оператор >>=

[1,2,3] >>= \x -> [sin x] →
[sin 1, sin 2, sin 3]

Можно удалять элементы
[2, -4, 3, -8, -9, 4] →
[2, 3, 4]

[2, -4, 3, -8, -9, 4] >>= \x -> if x < 0 then
[]
else [x*x]
→ [2, 3, 4]

которые состоят из целых чисел, переменной X и операции сложения и умножения

data Expr = Num Integer | X | Add Expr Expr | Mult Expr Expr deriving Show
или м.б. deriving (Show, Eq)

Примеры:

Add X (Num 1)
Так мы записываем x+!

Mult X (Add (Num 1) (Mult X X))
Так мы записываем x*(1+x*x)

30, 81, 90, 100, 243, …

map (*3) ham →
3, 9, 27, 30, 81, 90, 243, …
Не хватает только 1, 10, 100, 1000, …
Как добавить?
merge!

ham = merge (map (*3) ham) ([10^n | i<-[0..] ])

Или, та же идея, но другой вариант:

ham = 1 : merge (map (*3) ham) (map (*10) ham)

pascal
getNext xs =
[1] ++
zipWith (+) xs (tail xs)
++ [1]

Или, без вспомогательной функции:
pascal = [1] : map (\xs -> [1] ++zipWith (+) xs (tail xs)++ [1]) pascal