add a test that will fail given a strict implementation of accumulate

accumulate/accumulate_test.hs

@@ -32,4 +32,9 @@ accumulateTests =
   , testCase "accumulate recursively" $
     [["a1", "a2", "a3"], ["b1", "b2", "b3"], ["c1", "c2", "c3"]] @=?
     accumulate (\c -> accumulate ((c:) . show) ([1, 2, 3] :: [Int])) "abc"
+  , testCase "accumulate non-strict" $
+    ["nice work!"] @=?
+    take 1 (accumulate id
+      ("nice work!" :
+       error "accumulate should be even lazier, don't use reverse!"))
   ]

accumulate/example.hs

@@ -1,17 +1,22 @@
 module Accumulate (accumulate) where
+
 accumulate :: (a -> b) -> [a] -> [b]
-accumulate = map
-{-
+accumulate _ [] = []
+accumulate f (x:xs) = f x : accumulate f xs
 
--- Some other definitions that are easily possible:
+{-
 
-accumulate = fmap
+-- Some other reasonable definitions:
 
 accumulate f = foldr ((:) . f) []
 
 accumulate f xs = [f x | x <- xs]
 
-accumulate f (x:xs) = f x : accumulate xs
-accumulate _ [] = []
+-- Commonly submitted inefficient solution (we test for this now):
+
+accumulate f xs = accumulate' []
+  where
+    accumulate' acc []     = acc
+    accumulate' acc (x:xs) = accumulate' (f x : acc) xs
 
 -}