initial commit, without homework

Author: MAnyKey

.gitignore

@@ -0,0 +1 @@
+*~

ITMOPrelude/List.hs

@@ -0,0 +1,169 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+module ITMOPrelude.List where
+
+import Prelude (Show,Read,error)
+import ITMOPrelude.Primitive
+
+---------------------------------------------
+-- Что надо делать?
+--
+-- Все undefined превратить в требуемые термы.
+-- Звёздочкой (*) отмечены места, в которых может потребоваться думать.
+
+---------------------------------------------
+-- Определение
+
+data List a = Nil |  Cons a (List a) deriving (Show,Read)
+
+---------------------------------------------
+-- Операции
+
+-- Длина списка
+length :: List a -> Nat
+length = undefined
+
+-- Склеить два списка за O(length a)
+(++) :: List a -> List a -> List a
+a ++ b = undefined
+
+-- Список без первого элемента
+tail :: List a -> List a
+tail = undefined
+
+-- Список без последнего элемента
+init :: List a -> List a
+init = undefined
+
+-- Первый элемент
+head :: List a -> a
+head = undefined
+
+-- Последний элемент
+last :: List a -> a
+last = undefined
+
+-- n первых элементов списка
+take :: Nat -> List a -> List a
+take = undefined
+
+-- Список без n первых элементов
+drop :: Nat -> List a -> List a
+drop = undefined
+
+-- Оставить в списке только элементы удовлетворяющие p
+filter :: (a -> Bool) -> List a -> List a
+filter p = undefined
+
+-- Обобщённая версия. Вместо "выбросить/оставить" p
+-- говорит "выбросить/оставить b".
+gfilter :: (a -> Maybe b) -> List a -> List b
+gfilter p = undefined
+
+-- Копировать из списка в результат до первого нарушения предиката
+-- takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2]
+takeWhile :: (a -> Bool) -> List a -> List a
+takeWhile = undefined
+
+-- Не копировать из списка в результат до первого нарушения предиката,
+-- после чего скопировать все элементы, включая первый нарушивший
+-- dropWhile (< 3) [1,2,3,4,1,2,3,4] == [3,4,1,2,3,4]
+dropWhile :: (a -> Bool) -> List a -> List a
+dropWhile = undefined
+
+-- Разбить список в пару (найбольший префикс удовлетворяющий p, всё остальное)
+span :: (a -> Bool) -> List a -> Pair (List a) (List a)
+span p = undefined
+
+-- Разбить список по предикату на (takeWhile p xs, dropWhile p xs),
+-- но эффективнее
+break :: (a -> Bool) -> List a -> Pair (List a) (List a)
+break = undefined
+
+-- n-ый элемент списка (считая с нуля)
+(!!) :: List a -> Nat -> a
+Nil !! n = error "!!: empty list"
+l  !! n = undefined
+
+-- Список задом на перёд
+reverse :: List a -> List a
+reverse = undefined
+
+-- (*) Все подсписки данного списка
+subsequences :: List a -> List (List a)
+subsequences Nil = Cons Nil Nil
+subsequences (Cons x xs) = undefined
+
+-- (*) Все перестановки элементов данного списка
+permutations :: List a -> List (List a)
+permutations = undefined
+
+-- (*) Если можете. Все перестановки элементов данного списка
+-- другим способом
+permutations' :: List a -> List (List a)
+permutations' = undefined
+
+-- Повторяет элемент бесконечное число раз
+repeat :: a -> List a
+repeat = undefined
+
+-- Левая свёртка
+-- порождает такое дерево вычислений:
+--         f
+--        / \
+--       f   ...
+--      / \
+--     f   l!!2
+--    / \
+--   f   l!!1
+--  / \
+-- z  l!!0
+foldl :: (a -> b -> a) -> a -> List b -> a
+foldl f z l = undefined
+
+-- Тот же foldl, но в списке оказываются все промежуточные результаты
+-- last (scanl f z xs) == foldl f z xs
+scanl :: (a -> b -> a) -> a -> List b -> List a
+scanl = undefined
+
+-- Правая свёртка
+-- порождает такое дерево вычислений:
+--    f
+--   /  \
+-- l!!0  f
+--     /  \
+--   l!!1  f
+--       /  \
+--    l!!2  ...
+--           \
+--            z
+--            
+foldr :: (a -> b -> b) -> b -> List a -> b
+foldr f z l = undefined
+
+-- Аналогично
+--  head (scanr f z xs) == foldr f z xs.
+scanr :: (a -> b -> b) -> b -> [a] -> [b]
+scanr = undefined
+
+-- Должно завершаться за конечное время
+finiteTimeTest = take (Succ $ Succ $ Succ $ Succ Zero) $ foldr (Cons) Nil $ repeat Zero
+
+-- Применяет f к каждому элементу списка
+map :: (a -> b) -> List a -> List b
+map f l = undefined
+
+-- Склеивает список списков в список
+concat :: List (List a) -> List a
+concat = undefined
+
+-- Эквивалент (concat . map), но эффективнее
+concatMap :: (a -> List b) -> List a -> List b
+concatMap = undefined
+
+-- Сплющить два списка в список пар длинны min (length a, length b)
+zip :: List a -> List b -> List (Pair a b)
+zip a b = undefined
+
+-- Аналогично, но плющить при помощи функции, а не конструктором Pair
+zipWith :: (a -> b -> c) -> List a -> List b -> List c
+zipWith = undefined

ITMOPrelude/Primitive.hs

@@ -0,0 +1,202 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+module ITMOPrelude.Primitive where
+
+import Prelude (Show,Read)
+
+---------------------------------------------
+-- Синтаксис лямбда-выражений
+
+-- Эквивалентные определения
+example1 x  = x
+example1'   = \x -> x
+example1''  = let y = \x -> x in y
+example1''' = y where
+    y = \x -> x
+
+-- Снова эквивалентные определения
+example2 x y  = x %+ y
+example2' x   = \y -> x %+ y
+example2''    = \x -> \y -> x %+ y
+example2'''   = \x y -> x %+ y
+example2''''  = let z = \x y -> x %+ y in z
+example2''''' = z where
+    z x = \y -> x %+ y
+
+-- Зацикленное выражение
+undefined = undefined
+
+-- Ниже следует реализовать все термы, состоящие из undefined заглушки.
+-- Любые термы можно переписывать (natEq и natLe --- хорошие кандидаты).
+
+-------------------------------------------
+-- Примитивные типы
+
+-- Тип с единственным элементом
+data Unit = Unit deriving (Show,Read)
+
+-- Пара, произведение
+data Pair a b = Pair { fst :: a, snd :: b } deriving (Show,Read)
+
+-- Вариант, копроизведение
+data Either a b = Left a | Right b deriving (Show,Read)
+
+-- Частый частный случай, изоморфно Either Unit a
+data Maybe a = Nothing | Just a deriving (Show,Read)
+
+-- Частый частный случай, изоморфно Either Unit Unit
+data Bool = False | True deriving (Show,Read)
+
+-- Следует отметить, что встроенный if с этим Bool использовать нельзя,
+-- зато case всегда работает.
+
+-- Ну или можно реализовать свой if
+if' True a b = a
+if' False a b = b
+
+-- Трихотомия. Замечательный тип, показывающий результат сравнения
+data Tri = LE | EQ | GT deriving (Show,Read)
+
+-------------------------------------------
+-- Натуральные числа
+
+data Nat = Zero | Succ Nat deriving (Show,Read)
+
+natZero = Zero     -- 0
+natOne = Succ Zero -- 1
+
+-- Сравнивает два натуральных числа
+natCmp :: Nat -> Nat -> Tri
+natCmp = undefined
+
+-- n совпадает с m 
+natEq :: Nat -> Nat -> Bool
+natEq Zero     Zero     = True
+natEq Zero     (Succ _) = False
+natEq (Succ _) Zero     = False
+natEq (Succ n) (Succ m) = natEq n m
+
+-- n меньше m
+natLe :: Nat -> Nat -> Bool
+natLe Zero     Zero     = False
+natLe Zero     (Succ m) = True
+natLe (Succ n) Zero     = False
+natLe (Succ n) (Succ m) = natLe n m
+
+infixl 6 +.
+-- Сложение для натуральных чисел
+(+.) :: Nat -> Nat -> Nat
+Zero     +. m = m
+(Succ n) +. m = Succ (n +. m)
+
+infixl 6 -.
+-- Вычитание для натуральных чисел
+(-.) :: Nat -> Nat -> Nat
+n -. m = undefined
+
+infixl 7 *.
+-- Умножение для натуральных чисел
+(*.) :: Nat -> Nat -> Nat
+Zero     *. m = Zero
+(Succ n) *. m = m +. (n *. m)
+
+-- Целое и остаток от деления n на m
+natDivMod :: Nat -> Nat -> Pair Nat Nat
+natDivMod n m = undefined
+
+natDiv n = fst . natDivMod n -- Целое
+natMod n = snd . natDivMod n -- Остаток
+
+-- Поиск GCD алгоритмом Евклида (должен занимать 2 (вычислителельная часть) + 1 (тип) строчки)
+gcd :: Nat -> Nat -> Nat
+gcd = undefined
+
+-------------------------------------------
+-- Целые числа
+
+-- Требуется, чтобы представление каждого числа было единственным
+data Int = UNDEFINED deriving (Show,Read)
+
+intZero   = undefined   -- 0
+intOne    = undefined     -- 1
+intNegOne = undefined -- -1
+
+-- n -> - n
+intNeg :: Int -> Int
+intNeg = undefined
+
+-- Дальше также как для натуральных
+intCmp :: Int -> Int -> Tri
+intCmp = undefined
+
+intEq :: Int -> Int -> Bool
+intEq = undefined
+
+intLe :: Int -> Int -> Bool
+intLe = undefined
+
+infixl 6 .+., .-.
+-- У меня это единственный страшный терм во всём файле
+(.+.) :: Int -> Int -> Int
+n .+. m = undefined
+
+(.-.) :: Int -> Int -> Int
+n .-. m = n .+. (intNeg m)
+
+infixl 7 .*.
+(.*.) :: Int -> Int -> Int
+n .*. m = undefined
+
+-------------------------------------------
+-- Рациональные числа
+
+data Rat = Rat Int Nat
+
+ratNeg :: Rat -> Rat
+ratNeg (Rat x y) = Rat (intNeg x) y
+
+-- У рациональных ещё есть обратные элементы
+ratInv :: Rat -> Rat
+ratInv = undefined
+
+-- Дальше как обычно
+ratCmp :: Rat -> Rat -> Tri
+ratCmp = undefined
+
+ratEq :: Rat -> Rat -> Bool
+ratEq = undefined
+
+ratLe :: Rat -> Rat -> Bool
+ratLe = undefined
+
+infixl 7 %+, %-
+(%+) :: Rat -> Rat -> Rat
+n %+ m = undefined
+
+(%-) :: Rat -> Rat -> Rat
+n %- m = n %+ (ratNeg m)
+
+infixl 7 %*, %/
+(%*) :: Rat -> Rat -> Rat
+n %* m = undefined
+
+(%/) :: Rat -> Rat -> Rat
+n %/ m = n %* (ratInv m)
+
+-------------------------------------------
+-- Операции над функциями.
+-- Определены здесь, но использовать можно и выше
+
+infixr 9 .
+f . g = \ x -> f (g x)
+
+infixr 0 $
+f $ x = f x
+
+-- Эквивалентные определения
+example3   a b c = gcd a (gcd b c)
+example3'  a b c = gcd a $ gcd b c
+example3'' a b c = ($) (gcd a) (gcd b c)
+
+-- И ещё эквивалентные определения
+example4  a b x = (gcd a (gcd b x))
+example4' a b = gcd a . gcd b