Change structure of examples, tests, bench, and tests-examples to properly match src structure

Author: tbagrel1

bench/Data/Mutable/Array.hs renamed to bench/Bench/Data/Array/Mutable.hs

@@ -11,7 +11,7 @@
 -- land in a file named “Array.dump-simpl”
 -- {-# OPTIONS_GHC -ddump-simpl -ddump-to-file -dsuppress-all -dsuppress-uniques #-}
 
-module Data.Mutable.Array (benchmarks) where
+module Bench.Data.Array.Mutable (benchmarks) where
 
 import Control.DeepSeq (rnf)
 import qualified Data.Array.Mutable.Linear as Array.Linear

bench/Data/Mutable/Quicksort.hs renamed to bench/Bench/Data/Array/Mutable/Quicksort.hs

@@ -1,28 +1,16 @@
 {-# LANGUAGE NumericUnderscores #-}
 
-module Data.Mutable.Quicksort (benchmarks) where
+module Bench.Data.Array.Mutable.Quicksort (benchmarks) where
 
 import Control.DeepSeq (force)
 import Control.Exception (evaluate)
+import Data.Array.Mutable.Quicksort (qsortUsingArray, qsortUsingList)
 import Data.List (sort)
-import Simple.Quicksort (quickSort)
 import System.Random
 import Test.Tasty.Bench
 
 -- Follows thread from https://discourse.haskell.org/t/linear-haskell-quicksort-performance/10280
 
-qs :: (Ord a) => [a] -> [a]
-qs [] = []
-qs (x : xs) = qs ltx ++ x : qs gex
-  where
-    ltx = [y | y <- xs, y < x]
-    gex = [y | y <- xs, y >= x]
-
-linArrayQuicksort, lazyListQuicksort, stdLibSort :: [Int] -> [Int]
-linArrayQuicksort = quickSort
-lazyListQuicksort = qs
-stdLibSort = sort
-
 gen :: StdGen
 gen = mkStdGen 4541645642
 
@@ -40,12 +28,12 @@ benchmarks =
           env (randomListBuilder size) $ \randomList ->
             bgroup
               ("size " ++ (show size))
-              [ bench "linArrayQuicksort" $
-                  nf linArrayQuicksort randomList,
-                bench "lazyListQuicksort" $
-                  nf lazyListQuicksort randomList,
-                bench "stdLibSort" $
-                  nf stdLibSort randomList
+              [ bench "qsortUsingArray" $
+                  nf qsortUsingArray randomList,
+                bench "qsortUsingList" $
+                  nf qsortUsingList randomList,
+                bench "sortStdLib" $
+                  nf sort randomList
               ]
       )
         <$> sizes

bench/Data/Mutable/HashMap.hs renamed to bench/Bench/Data/HashMap/Mutable.hs

@@ -11,7 +11,7 @@
 {-# LANGUAGE StandaloneDeriving #-}
 {-# LANGUAGE TupleSections #-}
 
-module Data.Mutable.HashMap (benchmarks) where
+module Bench.Data.HashMap.Mutable (benchmarks) where
 
 import Control.DeepSeq (NFData (..), deepseq, force)
 import qualified Control.Monad.Random as Random

bench/Main.hs

@@ -1,14 +1,14 @@
 module Main where
 
-import qualified Data.Mutable.Array as Array
-import qualified Data.Mutable.HashMap as HashMap
-import qualified Data.Mutable.Quicksort as Quicksort
+import qualified Bench.Data.Array.Mutable as Array
+import qualified Bench.Data.Array.Mutable.Quicksort as Quicksort
+import qualified Bench.Data.HashMap.Mutable as HashMap
 import Test.Tasty.Bench (defaultMain)
 
 main :: IO ()
 main = do
   defaultMain
     [ Array.benchmarks,
-      HashMap.benchmarks,
-      Quicksort.benchmarks
+      Quicksort.benchmarks,
+      HashMap.benchmarks
     ]

examples/Simple/Quicksort.hs renamed to examples/Data/Array/Mutable/Quicksort.hs

@@ -6,7 +6,7 @@
 -- {-# OPTIONS_GHC -ddump-simpl -ddump-to-file -dsuppress-all -dsuppress-uniques #-}
 
 -- | This module implements quicksort with mutable arrays from linear-base
-module Simple.Quicksort where
+module Data.Array.Mutable.Quicksort where
 
 import Data.Array.Mutable.Linear (Array)
 import qualified Data.Array.Mutable.Linear as Array
@@ -17,15 +17,22 @@ import Prelude.Linear hiding (partition)
 -- # Quicksort
 -------------------------------------------------------------------------------
 
-quickSort :: [Int] -> [Int]
-quickSort xs = unur $ Array.fromList xs $ Array.toList . arrQuicksort
+qsortUsingList :: (Ord a) => [a] -> [a]
+qsortUsingList [] = []
+qsortUsingList (x : xs) = qsortUsingList ltx ++ x : qsortUsingList gex
+  where
+    ltx = [y | y <- xs, y < x]
+    gex = [y | y <- xs, y >= x]
 
-arrQuicksort :: Array Int %1 -> Array Int
-arrQuicksort arr =
+qsortUsingArray :: (Ord a) => [a] -> [a]
+qsortUsingArray xs = unur $ Array.fromList xs $ Array.toList . qsortArray
+
+qsortArray :: (Ord a) => Array a %1 -> Array a
+qsortArray arr =
   Array.size arr
     & \(Ur len, arr1) -> go 0 (len - 1) arr1
 
-go :: Int -> Int -> Array Int %1 -> Array Int
+go :: (Ord a) => Int -> Int -> Array a %1 -> Array a
 go lo hi arr
   | lo >= hi = arr
   | otherwise =
@@ -43,23 +50,23 @@ go lo hi arr
 -- @arr'[j] > pivot@ for @ix < j <= hi@,
 -- @arr'[k] = arr[k]@ for @k < lo@ and @k > hi@, and
 -- @arr'@ is a permutation of @arr@.
-partition :: Array Int %1 -> Int -> Int -> Int -> (Array Int, Ur Int)
-partition arr pivot lx rx
-  | (rx < lx) = (arr, Ur (lx - 1))
+partition :: (Ord a) => Array a %1 -> a -> Int -> Int -> (Array a, Ur Int)
+partition arr pivot lo hi
+  | (hi < lo) = (arr, Ur (lo - 1))
   | otherwise =
-      Array.read arr lx
+      Array.read arr lo
         & \(Ur lVal, arr1) ->
-          Array.read arr1 rx
+          Array.read arr1 hi
             & \(Ur rVal, arr2) -> case (lVal <= pivot, pivot < rVal) of
-              (True, True) -> partition arr2 pivot (lx + 1) (rx - 1)
-              (True, False) -> partition arr2 pivot (lx + 1) rx
-              (False, True) -> partition arr2 pivot lx (rx - 1)
+              (True, True) -> partition arr2 pivot (lo + 1) (hi - 1)
+              (True, False) -> partition arr2 pivot (lo + 1) hi
+              (False, True) -> partition arr2 pivot lo (hi - 1)
               (False, False) ->
-                swap arr2 lx rx
-                  & \arr3 -> partition arr3 pivot (lx + 1) (rx - 1)
+                swap arr2 lo hi
+                  & \arr3 -> partition arr3 pivot (lo + 1) (hi - 1)
 
 -- | @swap a i j@ exchanges the positions of values at @i@ and @j@ of @a@.
-swap :: (HasCallStack) => Array Int %1 -> Int -> Int -> Array Int
+swap :: (HasCallStack) => Array a %1 -> Int -> Int -> Array a
 swap arr i j =
   Array.read arr i
     & \(Ur ival, arr1) ->

examples/Simple/TopSort.hs renamed to examples/Data/HashMap/Mutable/TopSort.hs

@@ -5,7 +5,7 @@
 {-# OPTIONS_GHC -Wno-name-shadowing #-}
 {-# OPTIONS_GHC -Wno-unused-matches #-}
 
-module Simple.TopSort where
+module Data.HashMap.Mutable.TopSort where
 
 import Data.Bifunctor.Linear (second)
 import qualified Data.Functor.Linear as Data

examples/README.md

@@ -1,10 +1,12 @@
 # Examples
 
+ * `Data`
+   * These are examples of using the pure linear interface of mutable
+     data structures provided by linear base.
  * `Simple`
    * These are tutorial level examples for understanding linear
    types and using bread-and-butter tools in linear base.
    * Recommended order: `Pure`, `FileIO`.
  * `Foreign`
    * These are examples of explicitly allocating off the GC heap's
-   memory and on the system heap's memory
-
+   memory and on the system heap's memory.

linear-base.cabal

@@ -153,8 +153,8 @@ library examples
         Foreign.Heap
         Simple.FileIO
         Simple.Pure
-        Simple.Quicksort
-        Simple.TopSort
+        Data.Array.Mutable.Quicksort
+        Data.HashMap.Mutable.TopSort
     build-depends:
         base,
         linear-base,
@@ -169,12 +169,12 @@ test-suite test
     main-is:          Main.hs
     hs-source-dirs:   test
     other-modules:
-        Test.Data.Destination
-        Test.Data.Mutable.Array
-        Test.Data.Mutable.Vector
-        Test.Data.Mutable.HashMap
-        Test.Data.Mutable.Set
-        Test.Data.Polarized
+        Test.Data.Array.Destination
+        Test.Data.Array.Mutable
+        Test.Data.Vector.Mutable
+        Test.Data.HashMap.Mutable
+        Test.Data.Set.Mutable
+        Test.Data.Array.Polarized
         Test.Data.Functor.Linear
         Test.Data.V
         Test.Data.Replicator
@@ -200,7 +200,7 @@ test-suite test-examples
     hs-source-dirs:   test-examples
     other-modules:
         Test.Foreign
-        Test.Simple.Quicksort
+        Test.Data.Array.Mutable.Quicksort
     default-language: Haskell2010
     build-depends:
         base,
@@ -217,9 +217,9 @@ benchmark bench
     main-is:          Main.hs
     hs-source-dirs:   bench
     other-modules:
-        Data.Mutable.HashMap
-        Data.Mutable.Array
-        Data.Mutable.Quicksort
+        Bench.Data.HashMap.Mutable
+        Bench.Data.Array.Mutable
+        Bench.Data.Array.Mutable.Quicksort
     default-language: Haskell2010
     build-depends:
         base,

test-examples/Main.hs

@@ -1,7 +1,7 @@
 module Main where
 
+import Test.Data.Array.Mutable.Quicksort (quicksortTests)
 import Test.Foreign (foreignGCTests)
-import Test.Simple.Quicksort (quickSortTests)
 import Test.Tasty
 
 main :: IO ()
@@ -12,5 +12,5 @@ allTests =
   testGroup
     "All tests"
     [ foreignGCTests,
-      quickSortTests
+      quicksortTests
     ]

test-examples/Test/Data/Array/Mutable/Quicksort.hs

@@ -0,0 +1,29 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Test.Data.Array.Mutable.Quicksort (quicksortTests) where
+
+import Data.Array.Mutable.Quicksort (qsortUsingArray, qsortUsingList)
+import Data.List (sort)
+import Hedgehog
+import qualified Hedgehog.Gen as Gen
+import qualified Hedgehog.Range as Range
+import Test.Tasty
+import Test.Tasty.Hedgehog (testPropertyNamed)
+
+quicksortTests :: TestTree
+quicksortTests =
+  testGroup
+    "quicksort tests"
+    [ testPropertyNamed "sort xs === qsortUsingArray xs" "testQsortUsingArray" testQsortUsingArray,
+      testPropertyNamed "sort xs === qsortUsingList xs" "testQsortUsingList" testQsortUsingList
+    ]
+
+testQsortUsingArray :: Property
+testQsortUsingArray = property $ do
+  xs <- forAll $ Gen.list (Range.linear 0 1000) (Gen.int $ Range.linear 0 100)
+  sort xs === qsortUsingArray xs
+
+testQsortUsingList :: Property
+testQsortUsingList = property $ do
+  xs <- forAll $ Gen.list (Range.linear 0 1000) (Gen.int $ Range.linear 0 100)
+  sort xs === qsortUsingList xs