Практика 9.11

type Name = String
type DataBase = [(Name, Name)]

fathers :: DataBase
mothers :: DataBase

fathers = [("Bill", "John"),("Ann", "John"), ("John", "Piter"),
    ("Jane", "Kan"), ("Dorothy", "Alex"), ("Kan", "Lev"), ("Alice", "Ron"), ("Piter", "Tom")]
mothers = [("Bill", "Jane"), ("Ann", "Jane"), ("John", "Alice"), ("Jane", "Dorothy"),
    ("Alice", "Mary"), ("Piter", "Tona"), ("Dorothy", "Elen"), ("Kan", "Liza")]

getM :: Name -> Maybe Name
getM person = lookup person mothers --стрелка Клейсли
getF :: Name -> Maybe Name
getF person = lookup person fathers --стрелка Клейсли

--в терминале: do{f <- getF "Bill"; gm <- getMf; getM gm} (то же самое, что и выше)

--найдем бабушек по двум линиям
granmas :: Name -> Maybe (Name, Name)
granmas person = do
    m <- getM person
    gmm <- getM m
    f <- getF person
    gmf <- getM f
    return(gmm, gmf)

--дедушек по двум линиям
granfath :: Name -> Maybe (Name, Name)
granfath person = do
    m <- getM person
    gfm <- getF m
    f <- getF person
    gff <- getF f
    return(gfm, gff)


-- class Monad m where
--     return :: a -> m a
--     (>>=) :: m a -> (a -> m b) -> m b
--в терминале: [1,2]>>=(\x -> [x,x,x])
--             [1,1,1,2,2,2]

-- instance Monad [] where
--     return x = [x]
--     xs >>= k = concat (map k xs)
--в терминале: map(\x->[x,x,x]) [1,2]
--             [[1,1,1],[2,2,2]]

--[1,2]>>=(\x -> [])
--[]

--связь монады списка с генератором списка
list = [(x,y)| x <- [1,2,3], y <- [4,5,6]] --генератор списка

list1 = do --генератор списка в do-нотации
    x <- [1,2,3]
    y <- [4,5,6]
    return (x, y)

list2 =
    [1,2,3] >>= (\x ->
    [4,5,6] >>= (\y ->
    return (x, y)))

--условные вычисления внутри монадических
lst = [(x,y)|x <- [1,2,3], y <- [1,2], x/=y]

lst1 = do
    x <- [1,2,3]
    y <- [1,2]
    True <- return (x/=y)
    return (x,y)

lst2 =
    [1,2,3] >>= (\x ->
    [1,2] >>= (\y ->
    return (x/=y) >>= (\b -> case b of True -> return (x,y)
                                       _ -> fail "x")))
--написать ф-ю, принимающую число x, которое принимает (a, b, c)
pythT :: Int -> [(Int, Int, Int)]
pythT x = do
    a <- [1..x]
    b <- [1..x]
    c <- [1..x]
    True <- return (a < b)
    True <- return (c <= x)
    True <- return (a*a + b*b == c*c)
    return (a,b,c)

--экивалентно
pythT2 x = [(a, b, c)| a <- [1..x], b <- [1..x], c <- [1..x], a < b, c <= x, a*a + b*b == c*c]