import Test.QuickCheck import System.Time import System.CPUTime ----------------------------------------------------------------------- slow :: Integer -> Integer slow n | n <= 1 = 1 | otherwise = slow (n-1) + slow (n-2) if' :: Bool -> a -> a -> a if' False x y = x if' True x y = y examp1 = if' False 17 (slow 99) ----------------------------------------------------------------------- strange :: Bool -> Integer strange False = 17 strange True = 17 examp2 = strange undefined ----------------------------------------------------------------------- ones :: [Integer] ones = 1 : ones examp3 = take 10 ones ----------------------------------------------------------------------- printTable :: [String] -> IO () printTable xs = sequence_ [ putStrLn (show i ++ ": " ++ x) | (x,i) <- xs `zip` [1..] ] examp4 = printTable ["Häst", "Får", "Snigel"] ----------------------------------------------------------------------- replicate' :: Int -> a -> [a] replicate' n x = take n (repeat x) ----------------------------------------------------------------------- pairs :: [a] -> [(a,a)] pairs xs = xs `zip` tail (cycle xs) -- alternative definition pairs' :: [a] -> [(a,a)] pairs' xs = xs `zip` tail (xs ++ xs) ----------------------------------------------------------------------- group :: Int -> [a] -> [[a]] group n = takeWhile (not . null) . map (take n) . iterate (drop n) ----------------------------------------------------------------------- data Labyrinth = Crossroad { what :: String , left :: Labyrinth , right :: Labyrinth } deriving ( Eq, Show ) labyrinth :: Labyrinth labyrinth = start where start = Crossroad "start" forest town town = Crossroad "town" start forest forest = Crossroad "forest" town exit exit = Crossroad "exit" exit exit ----------------------------------------------------------------------- -- Two alternative solutions. Which one's faster? -- prime numbers, checking for each x that all prime numbers up to the square -- root of x do not divide the number primes :: [Integer] primes = 2 : [ x | x <- [3,5..], isPrime x ] where isPrime x = all (not . (`divides` x)) (takeWhile (\y -> y*y <= x) primes) -- prime numbers using a naive sieve primes2 :: [Integer] primes2 = sieve [2..] where sieve (x:xs) = x : sieve [ y | y <- xs, not (x `divides` y) ] -- divides divides :: Integer -> Integer -> Bool a `divides` b = b `mod` a == 0 -- comparison whichOne = do t1 <- getCPUTime let ps1 = take n primes print (sum ps1) t2 <- getCPUTime let ps2 = take n primes2 print (sum ps2) t3 <- getCPUTime putStrLn \$ (if t2-t1 < t3-t2 then "primes" else "primes2") ++ " is faster!" where n = 1000 -----------------------------------------------------------------------