--
-- You want to compile with, and with -O2, checking the rules are firing.
--
import Test.QuickCheck
import QuickCheckUtils
import System.Environment
import Text.Printf
import Data.ByteString.Fusion
import qualified Data.ByteString as P
import qualified Data.ByteString.Lazy as L
main = do
x <- getArgs
let n = if null x then 100 else read . head $ x
mapM_ (\(s,a) -> printf "%-25s: " s >> a n) tests
--
-- Test that, after loop fusion, our code behaves the same as the
-- unfused lazy or list models. Use -ddump-simpl to also check that
-- rules are firing for each case.
--
tests = -- 29/5/06, all tests are fusing:
[("down/down list", mytest prop_downdown_list) -- checked
,("down/filter list", mytest prop_downfilter_list) -- checked
,("down/map list", mytest prop_downmap_list) -- checked
,("filter/down lazy", mytest prop_filterdown_lazy) -- checked
,("filter/down list", mytest prop_filterdown_list) -- checked
,("filter/filter lazy", mytest prop_filterfilter_lazy) -- checked
,("filter/filter list", mytest prop_filterfilter_list) -- checked
,("filter/map lazy", mytest prop_filtermap_lazy) -- checked
,("filter/map list", mytest prop_filtermap_list) -- checked
,("filter/up lazy", mytest prop_filterup_lazy) -- checked
,("filter/up list", mytest prop_filterup_list) -- checked
,("map/down lazy", mytest prop_mapdown_lazy) -- checked
,("map/down list", mytest prop_mapdown_list) -- checked
,("map/filter lazy", mytest prop_mapfilter_lazy) -- checked
,("map/filter list", mytest prop_mapfilter_list) -- checked
,("map/map lazy", mytest prop_mapmap_lazy) -- checked
,("map/map list", mytest prop_mapmap_list) -- checked
,("map/up lazy", mytest prop_mapup_lazy) -- checked
,("map/up list", mytest prop_mapup_list) -- checked
,("up/filter lazy", mytest prop_upfilter_lazy) -- checked
,("up/filter list", mytest prop_upfilter_list) -- checked
,("up/map lazy", mytest prop_upmap_lazy) -- checked
,("up/map list", mytest prop_upmap_list) -- checked
,("up/up lazy", mytest prop_upup_lazy) -- checked
,("up/up list", mytest prop_upup_list) -- checked
,("noacc/noacc lazy", mytest prop_noacc_noacc_lazy) -- checked
,("noacc/noacc list", mytest prop_noacc_noacc_list) -- checked
,("noacc/up lazy", mytest prop_noacc_up_lazy) -- checked
,("noacc/up list", mytest prop_noacc_up_list) -- checked
,("up/noacc lazy", mytest prop_up_noacc_lazy) -- checked
,("up/noacc list", mytest prop_up_noacc_list) -- checked
,("map/noacc lazy", mytest prop_map_noacc_lazy) -- checked
,("map/noacc list", mytest prop_map_noacc_list) -- checked
,("noacc/map lazy", mytest prop_noacc_map_lazy) -- checked
,("noacc/map list", mytest prop_noacc_map_list) -- checked
,("filter/noacc lazy", mytest prop_filter_noacc_lazy) -- checked
,("filter/noacc list", mytest prop_filter_noacc_list) -- checked
,("noacc/filter lazy", mytest prop_noacc_filter_lazy) -- checked
,("noacc/filter list", mytest prop_noacc_filter_list) -- checked
,("noacc/down lazy", mytest prop_noacc_down_lazy) -- checked
,("noacc/down list", mytest prop_noacc_down_list) -- checked
-- ,("down/noacc lazy", mytest prop_down_noacc_lazy) -- checked
,("down/noacc list", mytest prop_down_noacc_list) -- checked
,("length/loop list", mytest prop_lengthloop_list)
-- ,("length/loop lazy", mytest prop_lengthloop_lazy)
,("maximum/loop list", mytest prop_maximumloop_list)
-- ,("maximum/loop lazy", mytest prop_maximumloop_lazy)
,("minimum/loop list", mytest prop_minimumloop_list)
-- ,("minimum/loop lazy", mytest prop_minimumloop_lazy)
]
prop_upup_list = eq3
(\f g -> P.foldl f (0::Int) . P.scanl g (0::W))
((\f g -> foldl f (0::Int) . scanl g (0::W)) :: (X -> W -> X) -> (W -> W -> W) -> [W] -> X)
prop_upup_lazy = eq3
(\f g -> L.foldl f (0::X) . L.scanl g (0::W))
(\f g -> P.foldl f (0::X) . P.scanl g (0::W))
prop_mapmap_list = eq3
(\f g -> P.map f . P.map g)
((\f g -> map f . map g) :: (W -> W) -> (W -> W) -> [W] -> [W])
prop_mapmap_lazy = eq3
(\f g -> L.map f . L.map g)
(\f g -> P.map f . P.map g)
prop_filterfilter_list = eq3
(\f g -> P.filter f . P.filter g)
((\f g -> filter f . filter g) :: (W -> Bool) -> (W -> Bool) -> [W] -> [W])
prop_filterfilter_lazy = eq3
(\f g -> L.filter f . L.filter g)
(\f g -> P.filter f . P.filter g)
prop_mapfilter_list = eq3
(\f g -> P.filter f . P.map g)
((\f g -> filter f . map g) :: (W -> Bool) -> (W -> W) -> [W] -> [W])
prop_mapfilter_lazy = eq3
(\f g -> L.filter f . L.map g)
(\f g -> P.filter f . P.map g)
prop_filtermap_list = eq3
(\f g -> P.map f . P.filter g)
((\f g -> map f . filter g) :: (W -> W) -> (W -> Bool) -> [W] -> [W])
prop_filtermap_lazy = eq3
(\f g -> L.map f . L.filter g)
(\f g -> P.map f . P.filter g)
prop_mapup_list = eq3
(\f g -> P.foldl g (0::W) . P.map f)
((\f g -> foldl g (0::W) . map f) :: (W -> W) -> (W -> W -> W) -> [W] -> W)
prop_mapup_lazy = eq3
(\f g -> L.foldl g (0::W) . L.map f) -- n.b. scan doesn't fuse here, atm
(\f g -> P.foldl g (0::W) . P.map f)
prop_upmap_list = eq3
(\f g -> P.map f . P.scanl g (0::W))
((\f g -> map f . scanl g (0::W)) :: (W -> W) -> (W -> W -> W) -> [W] -> [W])
prop_upmap_lazy = eq3
(\f g -> L.map f . L.scanl g (0::W))
(\f g -> P.map f . P.scanl g (0::W))
prop_filterup_list = eq3
(\f g -> P.foldl g (0::W) . P.filter f)
((\f g -> foldl g (0::W) . filter f) :: (W -> Bool) -> (W -> W -> W) -> [W] -> W)
prop_filterup_lazy = eq3
(\f g -> L.foldl g (0::W) . L.filter f)
(\f g -> P.foldl g (0::W) . P.filter f)
prop_upfilter_list = eq3
(\f g -> P.filter f . P.scanl g (0::W))
((\f g -> filter f . scanl g (0::W)) :: (W -> Bool) -> (W -> W -> W) -> [W] -> [W])
prop_upfilter_lazy = eq3
(\f g -> L.filter f . L.scanl g (0::W))
(\f g -> P.filter f . P.scanl g (0::W))
prop_downdown_list = eq3
(\f g -> P.foldr f (0::X) . P.scanr g (0::W))
((\f g -> foldr f (0::X) . scanr g (0::W)) :: (W -> X -> X) -> (W -> W -> W) -> [W] -> X)
{-
-- no lazy scanr yet
prop_downdown_lazy = eq3
(\f g -> L.foldr f (0::X) . L.scanr g (0::W))
(\f g -> P.foldr f (0::X) . P.scanr g (0::W))
-}
prop_mapdown_list = eq3
(\f g -> P.foldr g (0::W) . P.map f)
((\f g -> foldr g (0::W) . map f) :: (W -> W) -> (W -> W -> W) -> [W] -> W)
prop_mapdown_lazy = eq3
(\f g -> L.foldr g (0::W) . L.map f) -- n.b. scan doesn't fuse here, atm
(\f g -> P.foldr g (0::W) . P.map f)
prop_downmap_list = eq3
(\f g -> P.map f . P.scanr g (0::W))
((\f g -> map f . scanr g (0::W)) :: (W -> W) -> (W -> W -> W) -> [W] -> [W])
{-
prop_downmap_lazy = eq3
(\f g -> L.map f . L.scanr g (0::W))
(\f g -> P.map f . P.scanr g (0::W))
-}
prop_filterdown_list = eq3
(\f g -> P.foldr g (0::W) . P.filter f)
((\f g -> foldr g (0::W) . filter f) :: (W -> Bool) -> (W -> W -> W) -> [W] -> W)
prop_filterdown_lazy = eq3
(\f g -> L.foldr g (0::W) . L.filter f) -- n.b. scan doesn't fuse here, atm
(\f g -> P.foldr g (0::W) . P.filter f)
prop_downfilter_list = eq3
(\f g -> P.filter f . P.scanr g (0::W))
((\f g -> filter f . scanr g (0::W)) :: (W -> Bool) -> (W -> W -> W) -> [W] -> [W])
{-
prop_downfilter_lazy = eq3
(\f g -> L.filter f . L.scanr g (0::W))
(\f g -> P.filter f . P.scanr g (0::W))
-}
prop_noacc_noacc_list = eq5
(\f g h i -> (P.map f . P.filter g) . (P.map h . P.filter i))
((\f g h i -> ( map f . filter g) . ( map h . filter i))
:: (W -> W) -> (W -> Bool) -> (W -> W) -> (W -> Bool) -> [W] -> [W])
prop_noacc_noacc_lazy = eq5
(\f g h i -> (L.map f . L.filter g) . (L.map h . L.filter i))
(\f g h i -> (P.map f . P.filter g) . (P.map h . P.filter i))
prop_noacc_up_list = eq4
( \g h i -> P.foldl g (0::W) . (P.map h . P.filter i))
((\g h i -> foldl g (0::W) . ( map h . filter i))
:: (W -> W -> W) -> (W -> W) -> (W -> Bool) -> [W] -> W)
prop_noacc_up_lazy = eq4
(\g h i -> L.foldl g (0::W) . (L.map h . L.filter i))
(\g h i -> P.foldl g (0::W) . (P.map h . P.filter i))
prop_up_noacc_list = eq4
( \g h i -> (P.map h . P.filter i) . P.scanl g (0::W))
((\g h i -> ( map h . filter i) . scanl g (0::W))
:: (W -> W -> W) -> (W -> W) -> (W -> Bool) -> [W] -> [W])
prop_up_noacc_lazy = eq4
(\g h i -> (L.map h . L.filter i) . L.scanl g (0::W))
(\g h i -> (P.map h . P.filter i) . P.scanl g (0::W))
prop_map_noacc_list = eq4
( \g h i -> (P.map h . P.filter i) . P.map g)
((\g h i -> ( map h . filter i) . map g)
:: (W -> W) -> (W -> W) -> (W -> Bool) -> [W] -> [W])
prop_map_noacc_lazy = eq4
(\g h i -> (L.map h . L.filter i) . L.map g)
(\g h i -> (P.map h . P.filter i) . P.map g)
prop_noacc_map_list = eq4
( \g h i -> P.map g . (P.map h . P.filter i))
((\g h i -> map g . ( map h . filter i))
:: (W -> W) -> (W -> W) -> (W -> Bool) -> [W] -> [W])
prop_noacc_map_lazy = eq4
(\g h i -> L.map g . (L.map h . L.filter i))
(\g h i -> P.map g . (P.map h . P.filter i))
prop_filter_noacc_list = eq4
( \g h i -> (P.map h . P.filter i) . P.filter g)
((\g h i -> ( map h . filter i) . filter g)
:: (W -> Bool) -> (W -> W) -> (W -> Bool) -> [W] -> [W])
prop_filter_noacc_lazy = eq4
(\g h i -> (L.map h . L.filter i) . L.filter g)
(\g h i -> (P.map h . P.filter i) . P.filter g)
prop_noacc_filter_list = eq4
( \g h i -> P.filter g . (P.map h . P.filter i))
((\g h i -> filter g . ( map h . filter i))
:: (W -> Bool) -> (W -> W) -> (W -> Bool) -> [W] -> [W])
prop_noacc_filter_lazy = eq4
(\g h i -> L.filter g . (L.map h . L.filter i))
(\g h i -> P.filter g . (P.map h . P.filter i))
prop_noacc_down_list = eq4
( \g h i -> P.foldr g (0::W) . (P.map h . P.filter i))
((\g h i -> foldr g (0::W) . ( map h . filter i))
:: (W -> W -> W) -> (W -> W) -> (W -> Bool) -> [W] -> W)
prop_noacc_down_lazy = eq4
(\g h i -> L.foldr g (0::W) . (L.map h . L.filter i))
(\g h i -> P.foldr g (0::W) . (P.map h . P.filter i))
prop_down_noacc_list = eq4
( \g h i -> (P.map h . P.filter i) . P.scanr g (0::W))
((\g h i -> ( map h . filter i) . scanr g (0::W))
:: (W -> W -> W) -> (W -> W) -> (W -> Bool) -> [W] -> [W])
{-
prop_down_noacc_lazy = eq4
(\g h i -> (L.map h . L.filter i) . L.scanl g (0::W))
(\g h i -> (P.map h . P.filter i) . P.scanl g (0::W))
-}
------------------------------------------------------------------------
prop_lengthloop_list = eq2
(\f -> P.length . P.filter f)
((\f -> length . filter f) :: (W -> Bool) -> [W] -> X)
{-
prop_lengthloop_lazy = eq2
(\f g -> L.length . L.filter f) -- n.b. scan doesn't fuse here, atm
(\f g -> P.length . P.filter f)
-}
prop_maximumloop_list = eqnotnull2
(\f -> P.maximum . P.map f) -- so we don't get null strings
((\f -> maximum . map f) :: (W -> W) -> [W] -> W)
{-
prop_maximumloop_lazy = eq2
(\f g -> L.maximum . L.filter f) -- n.b. scan doesn't fuse here, atm
(\f g -> P.maximum . P.filter f)
-}
prop_minimumloop_list = eqnotnull2
(\f -> P.minimum . P.map f)
((\f -> minimum . map f) :: (W -> W) -> [W] -> W)
{-
prop_minimumloop_lazy = eq2
(\f g -> L.minimum . L.filter f) -- n.b. scan doesn't fuse here, atm
(\f g -> P.minimum . P.filter f)
-}
|
