module Chapter06 where

import Chapter02 (stdGravityMPS2)

-------------------------------------------------------
-- Exercise 6.1. --

type R = Double

yRock :: R -> R -> R
yRock :: R -> R -> R
yRock R
v0 R
t = R
0.5 R -> R -> R
forall a. Num a => a -> a -> a
* (-R
stdGravityMPS2) R -> R -> R
forall a. Num a => a -> a -> a
* R
t R -> R -> R
forall a. Floating a => a -> a -> a
** R
2 R -> R -> R
forall a. Num a => a -> a -> a
+ R
v0 R -> R -> R
forall a. Num a => a -> a -> a
* R
t

vRock :: R -> R -> R
vRock :: R -> R -> R
vRock R
v0 R
t = R
v0 R -> R -> R
forall a. Num a => a -> a -> a
- R
stdGravityMPS2 R -> R -> R
forall a. Num a => a -> a -> a
* R
t

-------------------------------------------------------

-- | Exercise 6.4.
greaterThanOrEq7' :: Int -> Bool
greaterThanOrEq7' :: Int -> Bool
greaterThanOrEq7' Int
n = Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
7

-- | Exercise 6.5. True if and only if s has length > n
isLongerThan :: Int -> String -> Bool
isLongerThan :: Int -> String -> Bool
isLongerThan Int
n String
s = String -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length String
s Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
n

-- | Exercise 6.6. Has more than 6 elements
hasMoreThan6Elements :: [a] -> Bool
hasMoreThan6Elements :: forall a. [a] -> Bool
hasMoreThan6Elements [a]
as = [a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
as Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
6

-- | Exercise 6.8.
first1000Squares :: [Integer]
first1000Squares :: [Integer]
first1000Squares = [Integer
n Integer -> Integer -> Integer
forall a b. (Num a, Integral b) => a -> b -> a
^ Integer
2 | Integer
n <- [Integer
0 .. Integer
999]]

-- | Exercise 6.9.
repeat' :: a -> [a]
repeat' :: forall a. a -> [a]
repeat' = (a -> a) -> a -> [a]
forall a. (a -> a) -> a -> [a]
iterate a -> a
forall a. a -> a
id

-- | Exercise 6.10.
replicate' :: Int -> a -> [a]
replicate' :: forall a. Int -> a -> [a]
replicate' Int
n a
a = Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
take Int
n ([a] -> [a]) -> [a] -> [a]
forall a b. (a -> b) -> a -> b
$ a -> [a]
forall a. a -> [a]
repeat a
a