doubleMe x = x + x
doubleUs x y = doubleMe x + doubleMe y
doubleSmallNumber x =
if x>100
then x
else
x * 2
doubleSmallNumber' x = (if x>100 then x else x * 2) + 1
boomBangs xs = [if x < 10 then "BOOM!" else "BANG!" | x <- xs, odd x]
length' xs = sum [1 | _ <- xs]
removeNonUpperCase st = [c | c <- st, c `elem` ['A'..'Z']]
rightTriangles = [ (a,b,c) | c <- [1..10], b <- [1..c], a <- [1..b], a^2 + b^2 == c^2]
addThree x y z = x + y + z
lucky :: Int -> String
lucky 7 = "You are lucky 7"
lucky x = "Sorry, you're out of luck, pal!"
addVectors :: (Double,Double) -> (Double,Double) -> (Double,Double)
addVectors (x1,y1) (x2,y2) = (x1+x2, y1+y2)
head' :: [a] -> a
head' [] = error "can't call head on an empty list, dummy!"
head' (x:_) = x
head'' :: [a] -> a
head'' xs =
case xs of
[] -> error "No head for empty list!"
(x:_) -> x
tell :: (Show a) => [a] -> String
tell [] = "list is empty!"
tell (x:[]) = "list has 1 elem:" ++ (show x)
tell (x:y:[]) = "list has 2 elem:" ++ (show x) ++ " and :" ++ show y
tell (x:y:_) = "list has more then 2 elem, front 2 is :" ++ (show x) ++ " and :" ++ show y
firstLetter :: String -> String
firstLetter "" = "Empty string!"
firstLetter all@(x:_) = "The first letter of [" ++ all ++ "] is:" ++ [x]
bmiTell :: Double -> String
bmiTell bmi
| bmi <= 18.5 = "You're under weight"
| bmi <= 25.0 = "You're supposed normal."
| bmi <= 30.0 = "You're fat!"
| otherwise = "You're a whale, congratulations!"
bmiTell' :: Double -> Double -> String
bmiTell' weight height
| weight / height ^ 2 <= 18.5 = "You're under weight"
| weight / height ^ 2 <= 25.0 = "You're supposed normal."
| weight / height ^ 2 <= 30.0 = "You're fat!"
| otherwise = "You're a whale, congratulations!"
bmiTell'' :: Double -> Double -> String
bmiTell'' weight height
| bmi <= 18.5 = "You're under weight"
| bmi <= 25.0 = "You're supposed normal."
| bmi <= 30.0 = "You're fat!"
| otherwise = "You're a whale, congratulations!"
where bmi = weight / height ^ 2
max' :: Ord a => a -> a -> a
max' x y
| x < y = y
| otherwise = x
calcBmis :: [(Double,Double)] -> [Double]
calcBmis xs = [ bmi w h | (w,h) <- xs]
where bmi weight height = weight / height ^ 2
cylinder :: Double -> Double -> Double
cylinder r h =
let sideArea = 2 * pi * r * h
topArea = pi * r ^ 2
in sideArea + 2 * topArea
calcBmis' :: [(Double, Double)] -> [Double]
calcBmis' xs = [bmi | (w, h) <- xs, let bmi = w / h ^ 2]
describeList :: [a] -> String
describeList ls = "This list is " ++ what ls
where what [] = "empty."
what [x] = " a single list."
what xs = " a longer list."
--递归
maximum' :: (Ord a) => [a] -> a
maximum' [] = error "maximum' of empty list"
maximum' [x] = x
maximum' (x:xs) = max x (maximum' xs)
replicate' :: Int -> a -> [a]
replicate' n x
| n <= 0 = []
| otherwise = x : replicate' (n-1) x
take' :: (Num i, Ord i) => i -> [a] -> [a]
take' n _
| n <= 0 = []
take' _ [] = []
take' n (x:xs) = x : take' (n-1) xs
reverse' :: [a] -> [a]
reverse' [] = []
reverse' (x:xs) = reverse' xs ++ [x]
elem' :: (Eq a) => a -> [a] -> Bool
elem' a [] = False
elem' a (x:xs)
| a == x = True
| otherwise = a `elem'` xs
--快速排序
quicksort :: (Ord a) => [a] -> [a]
quicksort [] = []
quicksort (x:xs) =
let smallerOrEqual = [a | a <- xs, a <= x]
larger = [a | a <- xs, a > x]
in quicksort smallerOrEqual ++ [x] ++ quicksort larger
quicksort' :: (Ord a) => [a] -> [a]
quicksort' [] = []
quicksort' (x:xs) =
let smallerOrEqual = filter (<=x) xs
larger = filter (>x) xs
in quicksort' smallerOrEqual ++ [x] ++ quicksort' larger
{-
第5章 高阶函数
柯里函数: 本质上,Haskell的所有函数都只有一个参数，我们见过所有
多参数的函数，都是“柯里函数”，柯里函数不会一次性取完所有的参数，
而是在每次调用时只取一个参数，并返回一个一元函数来取下一个参数，
以此类推。我们以部分参数来调用某函数，返回一个部分应用(partial
application) 函数。如: let f = (max 1 ) in f (-100)
-}
divideByTen :: (Floating a) => a -> a
divideByTen = (/10)
divide200 :: (Floating a) => a -> a
divide200 = (200 /)
--函数执行两次
applyTwice :: (a -> a) -> a -> a
applyTwice f x = f (f x)
zipWith' :: (a->b->c) -> [a] -> [b] -> [c]
zipWith' _ [] _ = []
zipWith' _ _ [] = []
zipWith' f (x:xs) (y:ys) = f x y : (zipWith' f xs ys)
flip' :: (a->b->c) -> b -> a -> c
flip' f y x = f x y
--map,filter
{-通过foldl函数进行左折叠，它从列表的左端开始折叠，用初始值
和列表的头部调用二元函数，得到一个新的累加值，并用新的累加值与列表
的下一个元素调用二元函数，依次类推-}
sum' :: (Num a) => [a] -> a
sum' xs = foldl (\acc x -> acc + x) 0 xs
{- "折叠": foldl1与foldr1的行为与 foldl和foldr相似，
只是无需要明确提供初始值-}
reverse1' :: [a] -> [a]
reverse1' = foldl (\acc x -> x : acc) []
reverse1'' :: [a] -> [a]
reverse1'' = foldl (flip (:)) []
product' :: Num a => [a] -> a
product' = foldl (*) 1
{-扫描: scanl,scanr和foldl,foldr相似，不过它们会将累加值的所有变动
记录到一个列表中。也有 scanl1,scanr1与折叠foldl1,foldr1类似-}
--自然数平方根之和累加，到哪个数时，累加值超过1000？
sqrtSums :: Int
sqrtSums = length(takeWhile (<1000) (scanl1 (+) (map sqrt [1..]))) + 1
