-- | Purely functional data structures, -- First example: reversing a list -- Functional Programming course 2017. -- Thomas Hallgren {- This started as a skeleton, the definitions were filled in during the lecture. -} -------------------------------------------------------------------------------- import Prelude hiding (sum,reverse) -- | Computing the sum of a list of numbers sum :: [Int] -> Int sum [] = 0 sum (x:xs) = x+sum xs -- | Reversing a list reverseSlow :: [a] -> [a] reverseSlow [] = [] reverseSlow (x:xs) = reverseSlow xs ++ [x] -- | Reverse a list by divide-and-conquer reverse2 :: [a] -> [a] reverse2 [] = [] reverse2 [x] = [x] reverse2 xs = reverse2 xs2 ++ reverse2 xs1 where (xs1,xs2) = splitAt n xs n = length xs `div` 2 -- A more efficient way to reverse a list... reverse :: [a] -> [a] reverse xs = reverseOnto xs [] reverseOnto :: [a] -> [a] -> [a] reverseOnto [] rs = rs reverseOnto (x:xs) rs = reverseOnto xs (x:rs) {- Below are the tests we ran in GHCi :load Reverse.hs :set +s sum ([1..10000]) sum ([1..100000]) sum ([1..1000000]) sum (reverseSlow [1..10000]) sum (reverseSlow [1..100000]) :r reverse2 [1..10] :r reverse2 [1..10] sum (reverse2 [1..10000]) sum (reverse2 [1..100000]) sum (reverse2 [1..1000000]) :r :t reverse :t reverseOnto sum (reverse [1..10000]) sum (reverse [1..100000]) sum (reverse [1..1000000]) -}