From e6b2f5f2a9f3dde39f9590a3c05722187b62d00b Mon Sep 17 00:00:00 2001
From: Miles Frain <miles.frain@colorado.edu>
Date: Fri, 18 Dec 2020 15:03:26 -0800
Subject: [PATCH 1/3] Add foldr benchmarking

---
 bench/Bench/Data/List.purs | 51 +++++++++++++-------------------------
 1 file changed, 17 insertions(+), 34 deletions(-)

diff --git a/bench/Bench/Data/List.purs b/bench/Bench/Data/List.purs
index e232f49..c51aeec 100644
--- a/bench/Bench/Data/List.purs
+++ b/bench/Bench/Data/List.purs
@@ -1,48 +1,31 @@
 module Bench.Data.List where
 
 import Prelude
+import Data.Maybe (fromMaybe)
+import Data.Foldable (maximum)
+import Data.List (List(..), take, range, foldr, length, (:))
+import Data.Traversable (traverse_)
 import Effect (Effect)
 import Effect.Console (log)
 import Performance.Minibench (bench)
 
-import Data.List as L
-
 benchList :: Effect Unit
 benchList = do
-  log "map"
-  log "---"
-  benchMap
+  benchLists "map" $ map (_ + 1)
+  benchLists "foldr" $ foldr add 0
 
   where
 
-  benchMap = do
-    let nats = L.range 0 999999
-        mapFn = map (_ + 1)
-        list1000    = L.take 1000 nats
-        list2000    = L.take 2000 nats
-        list5000    = L.take 5000 nats
-        list10000   = L.take 10000 nats
-        list100000  = L.take 100000 nats
-
-    log "map: empty list"
-    let emptyList = L.Nil
-    bench \_ -> mapFn emptyList
-
-    log "map: singleton list"
-    let singletonList = L.Cons 0 L.Nil
-    bench \_ -> mapFn singletonList
-
-    log $ "map: list (" <> show (L.length list1000) <> " elems)"
-    bench \_ -> mapFn list1000
-
-    log $ "map: list (" <> show (L.length list2000) <> " elems)"
-    bench \_ -> mapFn list2000
-
-    log $ "map: list (" <> show (L.length list5000) <> " elems)"
-    bench \_ -> mapFn list5000
+  listSizes = 0 : 1 : 1000 : 2000 : 5000 : 10000 : 100000 : Nil
+  nats = range 0 $ (fromMaybe 0 $ maximum listSizes) - 1
+  lists = map (\n -> take n nats) listSizes
 
-    log $ "map: list (" <> show (L.length list10000) <> " elems)"
-    bench \_ -> mapFn list10000
+  benchLists :: forall b. String -> (List Int -> b) -> Effect Unit
+  benchLists label func =
+    traverse_ (benchAList label func) lists
 
-    log $ "map: list (" <> show (L.length list100000) <> " elems)"
-    bench \_ -> mapFn list100000
+  benchAList :: forall a b. String -> (List a -> b) -> List a -> Effect Unit
+  benchAList label func list = do
+    log "---"
+    log $ label <> ": list (" <> show (length list) <> " elems)"
+    bench \_ -> func list
\ No newline at end of file

From 45e577b844f7238493fbfb9378fe84e2bd89f7a5 Mon Sep 17 00:00:00 2001
From: Miles Frain <miles.frain@colorado.edu>
Date: Fri, 18 Dec 2020 16:35:24 -0800
Subject: [PATCH 2/3] even exponential spacing of list sizes

---
 bench/Bench/Data/List.purs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/bench/Bench/Data/List.purs b/bench/Bench/Data/List.purs
index c51aeec..c40fe60 100644
--- a/bench/Bench/Data/List.purs
+++ b/bench/Bench/Data/List.purs
@@ -1,9 +1,10 @@
 module Bench.Data.List where
 
 import Prelude
-import Data.Maybe (fromMaybe)
 import Data.Foldable (maximum)
-import Data.List (List(..), take, range, foldr, length, (:))
+import Data.Int (pow)
+import Data.List (List(..), take, range, foldr, length)
+import Data.Maybe (fromMaybe)
 import Data.Traversable (traverse_)
 import Effect (Effect)
 import Effect.Console (log)
@@ -16,7 +17,7 @@ benchList = do
 
   where
 
-  listSizes = 0 : 1 : 1000 : 2000 : 5000 : 10000 : 100000 : Nil
+  listSizes = Cons 0 $ map (pow 10) $ range 0 5
   nats = range 0 $ (fromMaybe 0 $ maximum listSizes) - 1
   lists = map (\n -> take n nats) listSizes
 

From f7462ea1bf0ef0ad6b964b3b192df72a956b8dc3 Mon Sep 17 00:00:00 2001
From: Miles Frain <miles.frain@colorado.edu>
Date: Fri, 18 Dec 2020 15:56:36 -0800
Subject: [PATCH 3/3] faster foldr

---
 src/Data/List/Types.purs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/Data/List/Types.purs b/src/Data/List/Types.purs
index acd5aa1..abefc0d 100644
--- a/src/Data/List/Types.purs
+++ b/src/Data/List/Types.purs
@@ -103,7 +103,10 @@ instance functorWithIndexList :: FunctorWithIndex Int List where
 instance foldableList :: Foldable List where
   foldr f b = foldl (flip f) b <<< rev
     where
-    rev = foldl (flip Cons) Nil
+    rev = go Nil
+      where
+      go acc Nil = acc
+      go acc (x : xs) = go (x : acc) xs
   foldl f = go
     where
     go b = case _ of