-
Notifications
You must be signed in to change notification settings - Fork 0
/
lists.hs
113 lines (86 loc) · 2.64 KB
/
lists.hs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
module MyLists where
import Data.Char
myEnumFromTo :: Enum a => a -> a -> [a]
myEnumFromTo a b = go a b []
where go a' b' xs
| (fromEnum a') > (fromEnum b') = xs
| otherwise = go (succ a') b' (xs ++ [a'])
separateBySpaces :: String -> [String]
separateBySpaces s = go s []
where go [] xs = xs
go s' xs = go rest $ xs ++ [nextWord]
where nextWord = (takeWhile notSpace s')
rest = drop 1 (dropWhile notSpace s')
notSpace = (/=)' '
ff :: Num a => a -> a
ff x = x
-- NF -- [1,2,3,4,5]
-- WHNF -- 1 : 2 : 3 : 4 : _
-- WHNF -- enumFromTo 1 10
-- WHNF -- length [1, 2, 3, 4, 5]
-- WHNF -- sum (enumFromTo 1 10)
-- Nei -- ['a'..'m'] ++ ['n'..'z']
-- WHNF -- (_, 'b')
myFilter :: String -> [String]
myFilter = filter (not . flip elem ["the", "a", "an"]) . words
zip' :: [a] -> [b] -> [(a,b)]
zip' [] _ = []
zip' _ [] = []
zip' (x:xs) (y:ys) = [(x,y)] ++ (zip xs ys)
zipWith' :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith' _ [] _ = []
zipWith' _ _ [] = []
zipWith' f (x:xs) (y:ys) = [f x y] ++ (zipWith' f xs ys)
zip'' :: [a] -> [b] -> [(a,b)]
zip'' = zipWith' (,)
-- chapter exercises
filterUpper :: String -> String
filterUpper = filter isUpper
capitalizeFirst :: String -> String
capitalizeFirst [] = []
capitalizeFirst (x:xs) = [toUpper x] ++ xs
capitalizeAll :: String -> String
capitalizeAll [] = []
capitalizeAll (x:xs) = [toUpper x] ++ capitalizeAll xs
getFirstCapital :: String -> Char
getFirstCapital = toUpper . head
-- standard functions
myOr :: [Bool] -> Bool
myOr [] = False
myOr (x:xs) = x || myOr xs
myAny :: (a -> Bool) -> [a] -> Bool
myAny f [] = False
myAny f (x:xs) = f(x) || myAny f xs
myElem :: Eq a => a -> [a] -> Bool
--myElem a [] = False
--myElem a (x:xs) = a == x || myElem a xs
myElem a = myAny (==a)
myReverse :: [a] -> [a]
myReverse [] = []
myReverse (x:xs) = myReverse xs ++ [x]
squish :: [[a]] -> [a]
squish [] = []
squish (x:xs) = x ++ squish xs
squishMap :: (a -> [b]) -> [a] -> [b]
squishMap f [] = []
squishMap f (x:xs) = f(x) ++ squishMap f xs
squishAgain :: [[a]] -> [a]
squishAgain = squishMap id
myMaximumBy :: (a -> a -> Ordering) -> [a] -> a
myMaximumBy f (x:xs) = go f xs x
where go f [] x = x
go f (x:xs) x' = case f x' x of
GT -> go f xs x'
LT -> go f xs x
EQ -> go f xs x'
myMinimumBy :: (a -> a -> Ordering) -> [a] -> a
myMinimumBy f (x:xs) = go f xs x
where go f [] x = x
go f (x:xs) x' = case f x' x of
GT -> go f xs x
LT -> go f xs x'
EQ -> go f xs x
mymax :: (Ord a) => [a] -> a
mymax = myMaximumBy compare
mymin :: (Ord a) => [a] -> a
mymin = myMinimumBy compare