Домашнее задание Haskell

import Data.Maybe
import Data.List

-- №1
infixr 5 |++|
(|++|) :: [a] -> [a] -> [a]
[] |++| a2 = a2
a1 |++| a2 = head a1 : tail a1 |++| a2

-- №2
myHead :: [a] -> a
myHead [] = error "empty list"
myHead (x : xs) = x

-- №3
myLast :: [a] -> a
myLast [] = error "empty list"
myLast [x] = x
myLast (x : xs) = myLast xs

-- №4
myTail :: [a] -> [a]
myTail [] = error "empty list"
myTail (x : xs) = xs

-- №5
myInit :: [a] -> [a]
myInit [] = error "empty list"
myInit [x] = []
myInit (x : xs) = x : myInit xs

-- №6
myUncons :: [a] -> Maybe (a, [a])
myUncons [] = Nothing
myUncons (x : xs) = Just (x, xs)

-- №7
mySingleton :: a -> [a]
mySingleton x = [x]

-- №8

-- 1-ый способ:
myNull1 :: [a] -> Bool
myNull1 [] = True
myNull1 _ = False

-- 2-ой способ:
myNull2 :: Foldable t => t a -> Bool
myNull2 = foldr (\ _ _ -> False) True

-- №9

-- 1-ый способ:
myLength1 :: [a] -> Int
myLength1 [] = 0
myLength1 (x : xs) = 1 + myLength1 xs

-- 2-ой способ:
myLength2 :: Foldable t => t a -> Int
myLength2 = foldr (\x -> (+) 1) 0

-- №10
myMap :: (a -> b) -> [a] -> [b]
myMap f [] = []
myMap f (x : xs) = f x : myMap f xs

-- №11
myReverse :: [a] -> [a]
myReverse a = rev a []
    where rev [] xss = xss
          rev (x : xs) xss = rev xs (x : xss)

-- №12
myIntersperse :: a -> [a] -> [a]
myIntersperse _ [] = []
myIntersperse _ [x] = [x]
myIntersperse c (x : xs) = x : c : myIntersperse c xs

-- №13
myIntercalate :: [a] -> [[a]] -> [a]
myIntercalate _ [] = []
myIntercalate _ [x] = x
myIntercalate s (x : xs) = x ++ s ++ myIntercalate s xs

-- №14
myFoldl :: (a -> b -> a) -> a -> [b] -> a
myFoldl f a [] = a
myFoldl f a (x : xs) = myFoldl f (a `f` x) xs

-- №15
myFoldl1 :: (a -> a -> a) -> [a] -> a
myFoldl1 f [] = error "empty list"
myFoldl1 f x = foldl f (head x) (tail x)

-- №16
myFoldr :: (a -> b -> b) -> b -> [a] -> b
myFoldr f b [] = b
myFoldr f b (x : xs) = x `f` myFoldr f b xs

-- №17
myFoldr1 :: (a -> a -> a) -> [a] -> a
myFoldr1 f [] = error "empty list"
myFoldr1 f x = foldr f (last x) (init x)

-- №18

-- 1-ый способ:
myConcat1 :: [[a]] -> [a]
myConcat1 [] = []
myConcat1 (x : xs) = x ++ myConcat1 xs

-- 2-ой способ:
myConcat2 :: Foldable t => t [a] -> [a]
myConcat2 = foldr (++) []

-- №19

-- 1-ый способ:
myConcatMap1 :: (a -> [b]) -> [a] -> [b]
myConcatMap1 f x = concat $ map f x

-- 2-ой способ:
myConcatMap2 :: (a -> [b]) -> [a] -> [b]
myConcatMap2 f [] = []
myConcatMap2 f (x : xs) = f x ++ myConcatMap2 f xs

-- №20

-- 1-ый способ:
myEnd1 :: [Bool] -> Bool
myEnd1 [] = True
myEnd1 (x : xs) = if not x then False else myEnd1 xs

-- 2-ой способ:
myEnd2 :: Foldable t => t Bool -> Bool
myEnd2 = foldr (&&) True

-- №21

-- 1-ый способ:
myOr1 :: [Bool] -> Bool
myOr1 [] = False
myOr1 (x : xs) = if x then True else myOr1 xs

-- 2-ой способ:
myOr2 :: Foldable t => t Bool -> Bool
myOr2 = foldr (||) False

-- №22
myAll :: (a -> Bool) -> [a] -> Bool
myAll f a = and $ map f a

-- №23
myAny :: (a -> Bool) -> [a] -> Bool
myAny f a = or $ map f a

-- №24
mySum :: (Foldable t, Num a) => t a -> a
mySum = foldr (+) 0

-- №25
myProduct :: (Foldable t, Num a) => t a -> a
myProduct = foldr (*) 1

-- №26
myMaximum :: (Foldable t, Ord a) => t a -> a
myMaximum = foldr1 max

-- №27
myMinimum :: (Foldable t, Ord a) => t a -> a
myMinimum = foldr1 min

-- №28
myScanl :: (b -> a -> b) -> b -> [a] -> [b]
myScanl f a [] = [a]
myScanl f a (x : xs) = a : myScanl f (a `f` x) xs

-- №29
myScanl1 :: (a -> a -> a) -> [a] -> [a]
myScanl1 f [] = []
myScanl1 f x = scanl f (head x) (tail x)

-- №30

-- 1-ый вариант:
myScanr :: (a -> b -> b) -> b -> [a] -> [b]
myScanr f b [] = [b]
myScanr f b (x : xs) = x `f` head sc : sc
    where sc = myScanr f b xs

-- 2-ой вариант:
myScanr' :: (a -> b -> b) -> b -> [a] -> [b]
myScanr' f b [] = [b]
myScanr' f b (x : xs) = x `f` q : qs
    where qs @(q : _) = myScanr' f b xs

-- №31
myScanr1 :: (a -> a -> a) -> [a] -> [a]
myScanr1 f [] = []
myScanr1 f x = scanr f (last x) (init x)