{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# OPTIONS_GHC -Wno-orphans #-}

-- This option is on for only one reason, It allows us to make a list of
-- functions, written as (\ w x y z -> Property) where each function uses
-- a different set of the arguments. By typeing the list as
-- [Int -> Key -> Map Key Int -> Set key -> Property], I can specify
-- the type of each of the parameters to the anonymous functions, without
-- repeating them for each of the over 100 items in the list.

module Test.Control.Iterate.SetAlgebra (setAlgTest) where

import Control.Iterate.BaseTypes (List (..), Sett (..), fromPairs)
import Control.Iterate.Collect (Collect (runCollect), one, when)
import Control.Iterate.Exp (Exp (..), Query (..), domElem, lift, rngSnd)
import Control.Iterate.SetAlgebra (
  compute,
  domEq,
  fifo,
  lifo,
  runBool,
  runSet,
  sameDomain,
 )
import Control.SetAlgebra (
  BaseRep (ListR, MapR, SetR, SingleR),
  Iter (element),
  Single (Fail),
  dom,
  eval,
  fromList,
  keysEqual,
  materialize,
  rng,
  setSingleton,
  singleton,
  (∈),
  (∉),
  (∪),
  (≍),
  (⋪),
  (⋫),
  (▷),
  (◁),
  (➖),
 )
import Data.Char (ord)
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import Data.MapExtras (intersectDomP, intersectDomPLeft)
import qualified Data.Set as Set
import Test.Tasty (TestTree, testGroup)
import Test.Tasty.HUnit (assertEqual, testCase)
import Test.Tasty.QuickCheck (
  Arbitrary (arbitrary),
  Gen,
  Property,
  choose,
  conjoin,
  counterexample,
  frequency,
  testProperty,
  vectorOf,
  (===),
 )

-- =========================================================
-- Some examples of Exp and tests
-- let's build a few things to test with

-- ==============================================================================================
-- Consider one of transactions that needs to compute the following.
-- ((dom stkcreds) ◁ delegs) ▷ (dom stpools)
-- We could express this in datalog as follows
-- ans(x,y) <- skcreds(x,z) and delegs(x,y) and stpools(y,w)
-- Or if collections: stkcreds, delegs, and stpools were lists of pairs as a comprehension
-- [ (x,y) | (x,z) <- skcreds, (x',y) <- delegs, x==x', (y',w) <- stpools, y=y' ]
-- This runs in time and space proportional to: size(dom skcreds) + size(dom delegs) + size(dom stpools) (perhaps even worse)
-- Or if  stkcreds, delegs, and stpools were Data.Map, we could use the Collection monad.
-- Even better, this will run in time and space proportional to: size((dom skcreds) ∩ (dom delegs))
-- See the example with timing above.

-- Even better,  stkcreds, delegs, and stpools can be any binary type construtors in the Iter class.

stkcred :: Map Int [Char]
deleg :: Map Int Char
stpool :: Map Char Int
stkcred :: Map Int String
stkcred = [(Int, String)] -> Map Int String
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
5, String
"a"), (Int
6, String
"q"), (Int
12, String
"r")]

deleg :: Map Int Char
deleg = [(Int, Char)] -> Map Int Char
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
n, String
chars String -> Int -> Char
forall a. HasCallStack => [a] -> Int -> a
!! Int
n) | Int
n <- [Int
1 .. Int
10]]

stpool :: Map Char Int
stpool = [(Char, Int)] -> Map Char Int
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Char
'A', Int
99), (Char
'C', Int
12), (Char
'F', Int
42), (Char
'R', Int
33), (Char
'Z', Int
99)]

-- =============== Build a few maps ===================

chars :: String
chars :: String
chars = String
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdeghijklmnopqrstuvwxyz0123456789"

m0 :: Map.Map Int Char
m0 :: Map Int Char
m0 = [(Int, Char)] -> Map Int Char
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
1, Char
'a'), (Int
2, Char
'z'), (Int
4, Char
'g')]

m12 :: Map.Map Int Char
m12 :: Map Int Char
m12 = [(Int, Char)] -> Map Int Char
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
n, String
chars String -> Int -> Char
forall a. HasCallStack => [a] -> Int -> a
!! Int
n) | Int
n <- [Int
0 .. String -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length String
chars Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1]]

-- ============ Some small Maps to And, Or, Diff, Guard, Project with =========

l1, l2 :: [(Int, String)]
l1 :: [(Int, String)]
l1 = [(Int
1, String
"a"), (Int
4, String
"d"), (Int
5, String
"e"), (Int
10, String
"j"), (Int
12, String
"l"), (Int
21, String
"v"), (Int
26, String
"z")]
l2 :: [(Int, String)]
l2 = [(Int
3, String
"c"), (Int
4, String
"d"), (Int
5, String
"e"), (Int
6, String
"f"), (Int
10, String
"j"), (Int
11, String
"k"), (Int
21, String
"v")]

l3 :: [(Int, Int)]
l3 :: [(Int, Int)]
l3 = [(Int
4, Int
12), (Int
9, Int
13), (Int
12, Int
44), (Int
55, Int
22)]

evens :: Sett Int ()
evens :: Sett Int ()
evens = BaseRep Sett Int ()
-> (() -> () -> ()) -> [(Int, ())] -> Sett Int ()
forall k (f :: * -> * -> *) v.
Ord k =>
BaseRep f k v -> (v -> v -> v) -> [(k, v)] -> f k v
fromList BaseRep Sett Int ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (\()
l ()
_r -> ()
l) [(Int
n, ()) | Int
n <- [Int
2, Int
4, Int
6, Int
8, Int
10, Int
12, Int
14, Int
16, Int
18, Int
20, Int
22, Int
24, Int
26]]

l4 :: [(Int, String)]
l4 :: [(Int, String)]
l4 =
  [ (Int
1, String
"m")
  , (Int
2, String
"a")
  , (Int
5, String
"z")
  , (Int
6, String
"b")
  , (Int
7, String
"r")
  , (Int
12, String
"w")
  , (Int
34, String
"v")
  , (Int
50, String
"q")
  , (Int
51, String
"l")
  , (Int
105, String
"Z")
  ]

l5 :: [(String, Int)]
l5 :: [(String, Int)]
l5 =
  [ (String
"a", Int
101)
  , (String
"b", Int
102)
  , (String
"c", Int
103)
  , (String
"f", Int
104)
  , (String
"m", Int
105)
  , (String
"q", Int
107)
  , (String
"s", Int
106)
  , (String
"w", Int
108)
  , (String
"y", Int
109)
  , (String
"zz", Int
110)
  ]

-- =================== Some sample (Exp t) =============================

z1 :: Map Int String
z1 :: Map Int String
z1 = [(Int, String)] -> Map Int String
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
3, String
"c"), (Int
4, String
"d"), (Int
5, String
"e"), (Int
6, String
"f"), (Int
10, String
"j"), (Int
11, String
"k"), (Int
21, String
"v")]

z2 :: Set.Set Int
z2 :: Set Int
z2 = [Int] -> Set Int
forall a. Ord a => [a] -> Set a
Set.fromList [Int
4, Int
6, Int
11, Int
13, Int
2]

z3 :: Map Int String
z3 :: Map Int String
z3 = [(Int, String)] -> Map Int String
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
9, String
"3"), (Int
10, String
"j"), (Int
30, String
"a")]

z4 :: Map Int String
z4 :: Map Int String
z4 = [(Int, String)] -> Map Int String
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
3, String
"c"), (Int
5, String
"e"), (Int
10, String
"j"), (Int
21, String
"v"), (Int
9, String
"3"), (Int
30, String
"a")]

-- ===================== test that compute works ======================

-- Test that computing  x::(Exp t) computes to the given object with type t.

evalTest :: (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest :: forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
nm Exp t
expr t
ans = String -> Assertion -> TestTree
testCase String
name (String -> t -> t -> Assertion
forall a.
(Eq a, Show a, HasCallStack) =>
String -> a -> a -> Assertion
assertEqual String
name (Exp t -> t
forall t. Exp t -> t
compute Exp t
expr) t
ans)
  where
    name :: String
name = (Exp t -> String
forall a. Show a => a -> String
show Exp t
expr String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" where Map? = " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
nm)

-- Test that (eval x) and runSet(x) get the same answers

evalCompile :: (Show (f k v), Ord k, Eq (f k v)) => Exp (f k v) -> TestTree
evalCompile :: forall (f :: * -> * -> *) k v.
(Show (f k v), Ord k, Eq (f k v)) =>
Exp (f k v) -> TestTree
evalCompile Exp (f k v)
expr = String -> Assertion -> TestTree
testCase String
name (String -> f k v -> f k v -> Assertion
forall a.
(Eq a, Show a, HasCallStack) =>
String -> a -> a -> Assertion
assertEqual String
name (Exp (f k v) -> f k v
forall t. Exp t -> t
compute Exp (f k v)
expr) (Exp (f k v) -> f k v
forall k (f :: * -> * -> *) v. Ord k => Exp (f k v) -> f k v
runSet Exp (f k v)
expr))
  where
    name :: String
name = (String
"compute and runSet of " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Exp (f k v) -> String
forall a. Show a => a -> String
show Exp (f k v)
expr String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" are the same")

evalTests :: TestTree
evalTests :: TestTree
evalTests =
  String -> [TestTree] -> TestTree
testGroup
    String
"eval tests"
    [ String -> Exp Bool -> Bool -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"m12" (Int
5 Int -> Exp (Sett Int ()) -> Exp Bool
forall k (g :: * -> * -> *) s.
(Show k, Ord k, Iter g, HasExp s (g k ())) =>
k -> s -> Exp Bool
∈ (Map Int Char -> Exp (Sett Int ())
forall k s (f :: * -> * -> *) v.
(Ord k, HasExp s (f k v)) =>
s -> Exp (Sett k ())
dom Map Int Char
m12)) Bool
True
    , String -> Exp Bool -> Bool -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"m12" (Int
70 Int -> Exp (Sett Int ()) -> Exp Bool
forall k (g :: * -> * -> *) s.
(Show k, Ord k, Iter g, HasExp s (g k ())) =>
k -> s -> Exp Bool
∈ (Map Int Char -> Exp (Sett Int ())
forall k s (f :: * -> * -> *) v.
(Ord k, HasExp s (f k v)) =>
s -> Exp (Sett k ())
dom Map Int Char
m12)) Bool
False
    , String -> Exp (Map Int Char) -> Map Int Char -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"m0" (Map Int Char
m0 Map Int Char -> Exp (Single Int Char) -> Exp (Map Int Char)
forall k v s1 (f :: * -> * -> *) s2 (g :: * -> * -> *).
(Show k, Show v, Ord k, HasExp s1 (f k v), HasExp s2 (g k v)) =>
s1 -> s2 -> Exp (f k v)
∪ (Int -> Char -> Exp (Single Int Char)
forall k v. Ord k => k -> v -> Exp (Single k v)
singleton Int
3 Char
'b')) ([(Int, Char)] -> Map Int Char
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
1, Char
'a'), (Int
2, Char
'z'), (Int
3, Char
'b'), (Int
4, Char
'g')])
    , String -> Exp (Map Int Char) -> Map Int Char -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"m0" ((Int -> Exp (Single Int ())
forall k. Ord k => k -> Exp (Single k ())
setSingleton Int
2) Exp (Single Int ()) -> Map Int Char -> Exp (Map Int Char)
forall k (g :: * -> * -> *) s1 s2 (f :: * -> * -> *) v.
(Ord k, Iter g, HasExp s1 (g k ()), HasExp s2 (f k v)) =>
s1 -> s2 -> Exp (f k v)
⋪ Map Int Char
m0) ([(Int, Char)] -> Map Int Char
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
1, Char
'a'), (Int
4, Char
'g')])
    , String -> Exp (Map Int Char) -> Map Int Char -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"m0" (Exp (Single Int Char) -> Exp (Sett Int ())
forall k s (f :: * -> * -> *) v.
(Ord k, HasExp s (f k v)) =>
s -> Exp (Sett k ())
dom (Int -> Char -> Exp (Single Int Char)
forall k v. Ord k => k -> v -> Exp (Single k v)
singleton Int
2 Char
'z') Exp (Sett Int ()) -> Map Int Char -> Exp (Map Int Char)
forall k (g :: * -> * -> *) s1 s2 (f :: * -> * -> *) v.
(Ord k, Iter g, HasExp s1 (g k ()), HasExp s2 (f k v)) =>
s1 -> s2 -> Exp (f k v)
⋪ Map Int Char
m0) ([(Int, Char)] -> Map Int Char
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
1, Char
'a'), (Int
4, Char
'g')])
    , String -> Exp (Map Int Char) -> Map Int Char -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"m0" (Exp (Single Char Int) -> Exp (Sett Int ())
forall k v s (f :: * -> * -> *).
(Ord k, Ord v, HasExp s (f k v)) =>
s -> Exp (Sett v ())
rng (Char -> Int -> Exp (Single Char Int)
forall k v. Ord k => k -> v -> Exp (Single k v)
singleton Char
'z' Int
2) Exp (Sett Int ()) -> Map Int Char -> Exp (Map Int Char)
forall k (g :: * -> * -> *) s1 s2 (f :: * -> * -> *) v.
(Ord k, Iter g, HasExp s1 (g k ()), HasExp s2 (f k v)) =>
s1 -> s2 -> Exp (f k v)
⋪ Map Int Char
m0) ([(Int, Char)] -> Map Int Char
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
1, Char
'a'), (Int
4, Char
'g')])
    , String -> Exp (Map Int Char) -> Map Int Char -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest
        String
"m0"
        (([(Int, Char)] -> Map Int Char
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
1, Char
'a'), (Int
2, Char
'n'), (Int
3, Char
'r')]) Map Int Char -> Exp (Single Int Char) -> Exp (Map Int Char)
forall k v s1 (f :: * -> * -> *) s2 (g :: * -> * -> *).
(Show k, Show v, Ord k, HasExp s1 (f k v), HasExp s2 (g k v)) =>
s1 -> s2 -> Exp (f k v)
∪ (Int -> Char -> Exp (Single Int Char)
forall k v. Ord k => k -> v -> Exp (Single k v)
singleton Int
2 Char
'b'))
        ([(Int, Char)] -> Map Int Char
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
1 :: Int, Char
'a'), (Int
2, Char
'n'), (Int
3, Char
'r')])
    , String -> Exp (List Int Char) -> List Int Char -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"m0" ([(Int
1, Char
'a'), (Int
3, Char
'r')] [(Int, Char)] -> Exp (Single Int Char) -> Exp (List Int Char)
forall k v s1 (f :: * -> * -> *) s2 (g :: * -> * -> *).
(Show k, Show v, Ord k, HasExp s1 (f k v), HasExp s2 (g k v)) =>
s1 -> s2 -> Exp (f k v)
∪ Int -> Char -> Exp (Single Int Char)
forall k v. Ord k => k -> v -> Exp (Single k v)
singleton Int
3 Char
'b') ([(Int, Char)] -> List Int Char
forall k v. Ord k => [(k, v)] -> List k v
UnSafeList [(Int
1 :: Int, Char
'a'), (Int
3, Char
'r')])
    , String -> Exp Bool -> Bool -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"m0" (Int
70 Int -> Exp (Sett Int ()) -> Exp Bool
forall k (g :: * -> * -> *) s.
(Show k, Ord k, Iter g, HasExp s (g k ())) =>
k -> s -> Exp Bool
∉ Map Int Char -> Exp (Sett Int ())
forall k s (f :: * -> * -> *) v.
(Ord k, HasExp s (f k v)) =>
s -> Exp (Sett k ())
dom Map Int Char
m12) Bool
True
    , String -> Exp (Map Int Char) -> Map Int Char -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest
        String
"((dom stkcred) ◁ deleg) ▷ (dom stpool)"
        ((Map Int String -> Exp (Sett Int ())
forall k s (f :: * -> * -> *) v.
(Ord k, HasExp s (f k v)) =>
s -> Exp (Sett k ())
dom Map Int String
stkcred Exp (Sett Int ()) -> Map Int Char -> Exp (Map Int Char)
forall k s1 s2 (f :: * -> * -> *) v.
(Ord k, HasExp s1 (Sett k ()), HasExp s2 (f k v)) =>
s1 -> s2 -> Exp (f k v)
◁ Map Int Char
deleg) Exp (Map Int Char) -> Exp (Sett Char ()) -> Exp (Map Int Char)
forall k (g :: * -> * -> *) v s1 (f :: * -> * -> *) s2.
(Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) =>
s1 -> s2 -> Exp (f k v)
▷ Map Char Int -> Exp (Sett Char ())
forall k s (f :: * -> * -> *) v.
(Ord k, HasExp s (f k v)) =>
s -> Exp (Sett k ())
dom Map Char Int
stpool)
        ([(Int, Char)] -> Map Int Char
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
5, Char
'F')])
    , String -> Exp (List Int String) -> List Int String -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"Range exclude 1" ([(Int, String)]
l4 [(Int, String)] -> Set String -> Exp (List Int String)
forall k (g :: * -> * -> *) v s1 (f :: * -> * -> *) s2.
(Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) =>
s1 -> s2 -> Exp (f k v)
⋫ Set String
forall a. Set a
Set.empty) ([(Int, String)] -> List Int String
forall k v. Ord k => [(k, v)] -> List k v
UnSafeList [(Int, String)]
l4)
    , String -> Exp (List Int String) -> List Int String -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"Range exclude 2" ([(Int, String)]
l4 [(Int, String)] -> Single String () -> Exp (List Int String)
forall k (g :: * -> * -> *) v s1 (f :: * -> * -> *) s2.
(Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) =>
s1 -> s2 -> Exp (f k v)
⋫ Single String ()
forall k v. Single k v
Fail) ([(Int, String)] -> List Int String
forall k v. Ord k => [(k, v)] -> List k v
UnSafeList [(Int, String)]
l4)
    , String -> Exp (List Int String) -> List Int String -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest
        String
"Range exclude 3"
        ([(Int, String)]
l4 [(Int, String)] -> Set String -> Exp (List Int String)
forall k (g :: * -> * -> *) v s1 (f :: * -> * -> *) s2.
(Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) =>
s1 -> s2 -> Exp (f k v)
⋫ [String] -> Set String
forall a. Ord a => [a] -> Set a
Set.fromList [String
"m", String
"Z"])
        ([(Int, String)] -> List Int String
forall k v. Ord k => [(k, v)] -> List k v
UnSafeList [(Int
2, String
"a"), (Int
5, String
"z"), (Int
6, String
"b"), (Int
7, String
"r"), (Int
12, String
"w"), (Int
34, String
"v"), (Int
50, String
"q"), (Int
51, String
"l")])
    , String -> Exp (Map Int String) -> Map Int String -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"DomExclude Union" ((Set Int
z2 Set Int -> Map Int String -> Exp (Map Int String)
forall k (g :: * -> * -> *) s1 s2 (f :: * -> * -> *) v.
(Ord k, Iter g, HasExp s1 (g k ()), HasExp s2 (f k v)) =>
s1 -> s2 -> Exp (f k v)
⋪ Map Int String
z1) Exp (Map Int String) -> Map Int String -> Exp (Map Int String)
forall k v s1 (f :: * -> * -> *) s2 (g :: * -> * -> *).
(Show k, Show v, Ord k, HasExp s1 (f k v), HasExp s2 (g k v)) =>
s1 -> s2 -> Exp (f k v)
∪ Map Int String
z3) Map Int String
z4
    , String -> Exp (Sett Int ()) -> Sett Int () -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"Set difference" (Set Int
z2 Set Int -> Exp (Sett Int ()) -> Exp (Sett Int ())
forall k (f :: * -> * -> *) (g :: * -> * -> *) s1 v s2 u.
(Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) =>
s1 -> s2 -> Exp (f k v)
➖ Map Int String -> Exp (Sett Int ())
forall k s (f :: * -> * -> *) v.
(Ord k, HasExp s (f k v)) =>
s -> Exp (Sett k ())
dom Map Int String
z1) (Set Int -> Sett Int ()
forall k. Set k -> Sett k ()
Sett ([Int] -> Set Int
forall a. Ord a => [a] -> Set a
Set.fromList [Int
2 :: Int, Int
13]))
    , Exp (Map Int Char) -> TestTree
forall (f :: * -> * -> *) k v.
(Show (f k v), Ord k, Eq (f k v)) =>
Exp (f k v) -> TestTree
evalCompile ((Map Int String -> Exp (Sett Int ())
forall k s (f :: * -> * -> *) v.
(Ord k, HasExp s (f k v)) =>
s -> Exp (Sett k ())
dom Map Int String
stkcred Exp (Sett Int ()) -> Map Int Char -> Exp (Map Int Char)
forall k s1 s2 (f :: * -> * -> *) v.
(Ord k, HasExp s1 (Sett k ()), HasExp s2 (f k v)) =>
s1 -> s2 -> Exp (f k v)
◁ Map Int Char
deleg) Exp (Map Int Char) -> Exp (Sett Char ()) -> Exp (Map Int Char)
forall k (g :: * -> * -> *) v s1 (f :: * -> * -> *) s2.
(Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) =>
s1 -> s2 -> Exp (f k v)
▷ Map Char Int -> Exp (Sett Char ())
forall k s (f :: * -> * -> *) v.
(Ord k, HasExp s (f k v)) =>
s -> Exp (Sett k ())
dom Map Char Int
stpool)
    , Exp (List Int String) -> TestTree
forall (f :: * -> * -> *) k v.
(Show (f k v), Ord k, Eq (f k v)) =>
Exp (f k v) -> TestTree
evalCompile ([(Int, String)]
l4 [(Int, String)] -> Set String -> Exp (List Int String)
forall k (g :: * -> * -> *) v s1 (f :: * -> * -> *) s2.
(Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) =>
s1 -> s2 -> Exp (f k v)
⋫ [String] -> Set String
forall a. Ord a => [a] -> Set a
Set.fromList [String
"m", String
"Z"])
    , Exp (Map Int Char) -> TestTree
forall (f :: * -> * -> *) k v.
(Show (f k v), Ord k, Eq (f k v)) =>
Exp (f k v) -> TestTree
evalCompile (Map Int Char
m0 Map Int Char -> Exp (Single Int Char) -> Exp (Map Int Char)
forall k v s1 (f :: * -> * -> *) s2 (g :: * -> * -> *).
(Show k, Show v, Ord k, HasExp s1 (f k v), HasExp s2 (g k v)) =>
s1 -> s2 -> Exp (f k v)
∪ Int -> Char -> Exp (Single Int Char)
forall k v. Ord k => k -> v -> Exp (Single k v)
singleton Int
3 Char
'b')
    , Exp (Map Int Char) -> TestTree
forall (f :: * -> * -> *) k v.
(Show (f k v), Ord k, Eq (f k v)) =>
Exp (f k v) -> TestTree
evalCompile (Int -> Exp (Single Int ())
forall k. Ord k => k -> Exp (Single k ())
setSingleton Int
2 Exp (Single Int ()) -> Map Int Char -> Exp (Map Int Char)
forall k (g :: * -> * -> *) s1 s2 (f :: * -> * -> *) v.
(Ord k, Iter g, HasExp s1 (g k ()), HasExp s2 (f k v)) =>
s1 -> s2 -> Exp (f k v)
⋪ Map Int Char
m0)
    , String -> Exp Bool -> Bool -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"ex1" (Int
5 Int -> Exp (Sett Int ()) -> Exp Bool
forall k (g :: * -> * -> *) s.
(Show k, Ord k, Iter g, HasExp s (g k ())) =>
k -> s -> Exp Bool
∈ Map Int Char -> Exp (Sett Int ())
forall k s (f :: * -> * -> *) v.
(Ord k, HasExp s (f k v)) =>
s -> Exp (Sett k ())
dom Map Int Char
m12) Bool
True
    , String -> Exp Bool -> Bool -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"ex2" (Int
70 Int -> Exp (Sett Int ()) -> Exp Bool
forall k (g :: * -> * -> *) s.
(Show k, Ord k, Iter g, HasExp s (g k ())) =>
k -> s -> Exp Bool
∈ Map Int Char -> Exp (Sett Int ())
forall k s (f :: * -> * -> *) v.
(Ord k, HasExp s (f k v)) =>
s -> Exp (Sett k ())
dom Map Int Char
m12) Bool
False
    , String -> Exp Bool -> Bool -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"ex3" (Int
70 Int -> Exp (Sett Int ()) -> Exp Bool
forall k (g :: * -> * -> *) s.
(Show k, Ord k, Iter g, HasExp s (g k ())) =>
k -> s -> Exp Bool
∉ Map Int Char -> Exp (Sett Int ())
forall k s (f :: * -> * -> *) v.
(Ord k, HasExp s (f k v)) =>
s -> Exp (Sett k ())
dom Map Int Char
m12) Bool
True
    , String -> Exp (Map Int Char) -> Map Int Char -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"ex4" (Map Int Char
m0 Map Int Char -> Exp (Single Int Char) -> Exp (Map Int Char)
forall k v s1 (f :: * -> * -> *) s2 (g :: * -> * -> *).
(Show k, Show v, Ord k, HasExp s1 (f k v), HasExp s2 (g k v)) =>
s1 -> s2 -> Exp (f k v)
∪ Int -> Char -> Exp (Single Int Char)
forall k v. Ord k => k -> v -> Exp (Single k v)
singleton Int
3 Char
'b') (Int -> Char -> Map Int Char -> Map Int Char
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Int
3 Char
'b' Map Int Char
m0)
    , String -> Exp (Map Int Char) -> Map Int Char -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"ex5" (Int -> Exp (Single Int ())
forall k. Ord k => k -> Exp (Single k ())
setSingleton Int
2 Exp (Single Int ()) -> Map Int Char -> Exp (Map Int Char)
forall k (g :: * -> * -> *) s1 s2 (f :: * -> * -> *) v.
(Ord k, Iter g, HasExp s1 (g k ()), HasExp s2 (f k v)) =>
s1 -> s2 -> Exp (f k v)
⋪ Map Int Char
m0) ([(Int, Char)] -> Map Int Char
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
1, Char
'a'), (Int
4, Char
'g')])
    , String -> Exp (Map Int Char) -> Map Int Char -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"ex6" (Exp (Single Int Char) -> Exp (Sett Int ())
forall k s (f :: * -> * -> *) v.
(Ord k, HasExp s (f k v)) =>
s -> Exp (Sett k ())
dom (Int -> Char -> Exp (Single Int Char)
forall k v. Ord k => k -> v -> Exp (Single k v)
singleton Int
2 Char
'z') Exp (Sett Int ()) -> Map Int Char -> Exp (Map Int Char)
forall k (g :: * -> * -> *) s1 s2 (f :: * -> * -> *) v.
(Ord k, Iter g, HasExp s1 (g k ()), HasExp s2 (f k v)) =>
s1 -> s2 -> Exp (f k v)
⋪ Map Int Char
m0) ([(Int, Char)] -> Map Int Char
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
1, Char
'a'), (Int
4, Char
'g')])
    , String -> Exp (Map Int Char) -> Map Int Char -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"ex7" (Exp (Single Char Int) -> Exp (Sett Int ())
forall k v s (f :: * -> * -> *).
(Ord k, Ord v, HasExp s (f k v)) =>
s -> Exp (Sett v ())
rng (Char -> Int -> Exp (Single Char Int)
forall k v. Ord k => k -> v -> Exp (Single k v)
singleton Char
'z' Int
2) Exp (Sett Int ()) -> Map Int Char -> Exp (Map Int Char)
forall k (g :: * -> * -> *) s1 s2 (f :: * -> * -> *) v.
(Ord k, Iter g, HasExp s1 (g k ()), HasExp s2 (f k v)) =>
s1 -> s2 -> Exp (f k v)
⋪ Map Int Char
m0) ([(Int, Char)] -> Map Int Char
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
1, Char
'a'), (Int
4, Char
'g')])
    , String -> Exp (Sett Int ()) -> Sett Int () -> TestTree
forall t. (Show t, Eq t) => String -> Exp t -> t -> TestTree
evalTest String
"ex8" (Set Int
z2 Set Int -> Exp (Sett Int ()) -> Exp (Sett Int ())
forall k (f :: * -> * -> *) (g :: * -> * -> *) s1 v s2 u.
(Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) =>
s1 -> s2 -> Exp (f k v)
➖ Map Int String -> Exp (Sett Int ())
forall k s (f :: * -> * -> *) v.
(Ord k, HasExp s (f k v)) =>
s -> Exp (Sett k ())
dom Map Int String
z1) (Set Int -> Sett Int ()
forall k. Set k -> Sett k ()
Sett (Set Int -> Sett Int ()) -> Set Int -> Sett Int ()
forall a b. (a -> b) -> a -> b
$ [Int] -> Set Int
forall a. Ord a => [a] -> Set a
Set.fromList [Int
13, Int
2])
    ]

-- =============== test of KeysEqual and its variants =====================

tree1, tree2, tree3 :: Map Int Int
tree1 :: Map Int Int
tree1 = [(Int, Int)] -> Map Int Int
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
i, Int
i :: Int) | Int
i <- [Int
1 .. Int
20]]
tree2 :: Map Int Int
tree2 = [(Int, Int)] -> Map Int Int
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
i, Int
i :: Int) | Int
i <- [Int] -> [Int]
forall a. [a] -> [a]
reverse [Int
2 .. Int
20] [Int] -> [Int] -> [Int]
forall a. [a] -> [a] -> [a]
++ [Int
1]]
tree3 :: Map Int Int
tree3 = [(Int, Int)] -> Map Int Int
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
i, Int
i :: Int) | Int
i <- [Int
1 .. Int
19]]

set1 :: Set.Set Int
set1 :: Set Int
set1 = [Int] -> Set Int
forall a. Ord a => [a] -> Set a
Set.fromList [Int
1 .. Int
20]

keysEqTests :: TestTree
keysEqTests :: TestTree
keysEqTests =
  String -> [TestTree] -> TestTree
testGroup
    String
"keysEqual tests"
    ( (Int -> (Bool, Bool) -> TestTree)
-> [Int] -> [(Bool, Bool)] -> [TestTree]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith
        Int -> (Bool, Bool) -> TestTree
forall {a} {a}. (Eq a, Show a, Show a) => a -> (a, a) -> TestTree
tst
        [(Int
1 :: Int) ..]
        [ (Map Int Int -> Map Int Int -> Bool
forall k v1 v2. Ord k => Map k v1 -> Map k v2 -> Bool
keysEqual Map Int Int
tree1 Map Int Int
tree2, Bool
True)
        , (Map Int Int -> Map Int Int -> Bool
forall k v1 v2. Ord k => Map k v1 -> Map k v2 -> Bool
keysEqual Map Int Int
tree2 Map Int Int
tree1, Bool
True)
        , (Map Int Int -> Map Int Int -> Bool
forall k v1 v2. Ord k => Map k v1 -> Map k v2 -> Bool
keysEqual Map Int Int
tree1 Map Int Int
tree3, Bool
False)
        , (Map Int Int -> Map Int Int -> Bool
forall k (f :: * -> * -> *) (g :: * -> * -> *) b c.
(Ord k, Iter f, Iter g) =>
f k b -> g k c -> Bool
sameDomain Map Int Int
tree1 Map Int Int
tree2, Bool
True)
        , (Map Int Int -> Map Int Int -> Bool
forall k (f :: * -> * -> *) (g :: * -> * -> *) b c.
(Ord k, Iter f, Iter g) =>
f k b -> g k c -> Bool
sameDomain Map Int Int
tree2 Map Int Int
tree1, Bool
True)
        , (Map Int Int -> Map Int Int -> Bool
forall k (f :: * -> * -> *) (g :: * -> * -> *) b c.
(Ord k, Iter f, Iter g) =>
f k b -> g k c -> Bool
sameDomain Map Int Int
tree1 Map Int Int
tree3, Bool
False)
        , (Exp Bool -> Bool
forall s t. Embed s t => Exp t -> s
eval (Map Int Int
tree1 Map Int Int -> Map Int Int -> Exp Bool
forall k (f :: * -> * -> *) (g :: * -> * -> *) s1 v s2 u.
(Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) =>
s1 -> s2 -> Exp Bool
≍ Map Int Int
tree2), Bool
True)
        , (Exp Bool -> Bool
forall s t. Embed s t => Exp t -> s
eval (Map Int Int
tree1 Map Int Int -> Map Int Int -> Exp Bool
forall k (f :: * -> * -> *) (g :: * -> * -> *) s1 v s2 u.
(Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) =>
s1 -> s2 -> Exp Bool
≍ Map Int Int
tree3), Bool
False)
        , (Exp Bool -> Bool
forall s t. Embed s t => Exp t -> s
eval (Map Int Int
tree1 Map Int Int -> Set Int -> Exp Bool
forall k (f :: * -> * -> *) (g :: * -> * -> *) s1 v s2 u.
(Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) =>
s1 -> s2 -> Exp Bool
≍ Set Int
set1), Bool
True)
        , (Exp Bool -> Bool
forall s t. Embed s t => Exp t -> s
eval (Map Int Int
tree3 Map Int Int -> Set Int -> Exp Bool
forall k (f :: * -> * -> *) (g :: * -> * -> *) s1 v s2 u.
(Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) =>
s1 -> s2 -> Exp Bool
≍ Set Int
set1), Bool
False)
        ]
    )
  where
    tst :: a -> (a, a) -> TestTree
tst a
n (a
x, a
y) = String -> Assertion -> TestTree
testCase (String
"keysEqual " String -> String -> String
forall a. [a] -> [a] -> [a]
++ a -> String
forall a. Show a => a -> String
show a
n) (String -> a -> a -> Assertion
forall a.
(Eq a, Show a, HasCallStack) =>
String -> a -> a -> Assertion
assertEqual (String
"keysEqual " String -> String -> String
forall a. [a] -> [a] -> [a]
++ a -> String
forall a. Show a => a -> String
show a
n) a
y a
x)

-- ========================== test that various Compound iterators work ================

testcase :: (Eq k, Eq v, Show k, Show v, Iter f) => String -> f k v -> [(k, v)] -> TestTree
testcase :: forall k v (f :: * -> * -> *).
(Eq k, Eq v, Show k, Show v, Iter f) =>
String -> f k v -> [(k, v)] -> TestTree
testcase String
nm f k v
col [(k, v)]
ans = String -> Assertion -> TestTree
testCase String
nm (String -> [(k, v)] -> [(k, v)] -> Assertion
forall a.
(Eq a, Show a, HasCallStack) =>
String -> a -> a -> Assertion
assertEqual String
nm [(k, v)]
ans (Collect (k, v) -> forall ans. ans -> ((k, v) -> ans -> ans) -> ans
forall tuple.
Collect tuple -> forall ans. ans -> (tuple -> ans -> ans) -> ans
runCollect (f k v -> Collect (k, v)
forall (f :: * -> * -> *) k v. Iter f => f k v -> Collect (k, v)
fifo f k v
col) [] (:)))

fromListD :: (Ord k, Iter f) => BaseRep f k v -> [(k, v)] -> Query k v
fromListD :: forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep f k v
rep [(k, v)]
xs = BaseRep f k v -> f k v -> Query k v
forall (f :: * -> * -> *) k v.
(Iter f, Ord k) =>
BaseRep f k v -> f k v -> Query k v
BaseD BaseRep f k v
rep (BaseRep f k v -> (v -> v -> v) -> [(k, v)] -> f k v
forall k (f :: * -> * -> *) v.
Ord k =>
BaseRep f k v -> (v -> v -> v) -> [(k, v)] -> f k v
fromList BaseRep f k v
rep (\v
l v
_r -> v
l) [(k, v)]
xs)

-- Tests where we vary how we represent l1 and l2 (the f in (Iter f) )
-- and see that we always get the same answer no matter how we store the data of l1 and l2

testAnd1
  , testAnd2
  , testOr
  , testDiff1
  , testDiff2 ::
    Iter g => String -> BaseRep g Int String -> TestTree
testAnd1 :: forall (g :: * -> * -> *).
Iter g =>
String -> BaseRep g Int String -> TestTree
testAnd1 String
nm BaseRep g Int String
rep =
  String
-> Query Int (String, String)
-> [(Int, (String, String))]
-> TestTree
forall k v (f :: * -> * -> *).
(Eq k, Eq v, Show k, Show v, Iter f) =>
String -> f k v -> [(k, v)] -> TestTree
testcase
    String
nm
    (Query Int String -> Query Int String -> Query Int (String, String)
forall k v1 w. Ord k => Query k v1 -> Query k w -> Query k (v1, w)
AndD (BaseRep g Int String -> [(Int, String)] -> Query Int String
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep g Int String
rep [(Int, String)]
l1) (BaseRep g Int String -> [(Int, String)] -> Query Int String
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep g Int String
rep [(Int, String)]
l2))
    [(Int
4, (String
"d", String
"d")), (Int
5, (String
"e", String
"e")), (Int
10, (String
"j", String
"j")), (Int
21, (String
"v", String
"v"))]
testAnd2 :: forall (g :: * -> * -> *).
Iter g =>
String -> BaseRep g Int String -> TestTree
testAnd2 String
nm BaseRep g Int String
rep =
  String -> Assertion -> TestTree
testCase
    String
nm
    ( String
-> [(Int, (String, String))]
-> [(Int, (String, String))]
-> Assertion
forall a.
(Eq a, Show a, HasCallStack) =>
String -> a -> a -> Assertion
assertEqual
        String
nm
        (Collect (Int, (String, String))
-> forall ans.
   ans -> ((Int, (String, String)) -> ans -> ans) -> ans
forall tuple.
Collect tuple -> forall ans. ans -> (tuple -> ans -> ans) -> ans
runCollect (Query Int (String, String) -> Collect (Int, (String, String))
forall (f :: * -> * -> *) k v. Iter f => f k v -> Collect (k, v)
lifo (Query Int String -> Query Int String -> Query Int (String, String)
forall k v1 w. Ord k => Query k v1 -> Query k w -> Query k (v1, w)
AndD (BaseRep g Int String -> [(Int, String)] -> Query Int String
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep g Int String
rep [(Int, String)]
l1) (BaseRep g Int String -> [(Int, String)] -> Query Int String
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep g Int String
rep [(Int, String)]
l2))) [] (:))
        ([(Int, (String, String))] -> [(Int, (String, String))]
forall a. [a] -> [a]
reverse [(Int
4, (String
"d", String
"d")), (Int
5, (String
"e", String
"e")), (Int
10, (String
"j", String
"j")), (Int
21, (String
"v", String
"v"))])
    )
testOr :: forall (g :: * -> * -> *).
Iter g =>
String -> BaseRep g Int String -> TestTree
testOr String
nm BaseRep g Int String
rep =
  String -> Query Int String -> [(Int, String)] -> TestTree
forall k v (f :: * -> * -> *).
(Eq k, Eq v, Show k, Show v, Iter f) =>
String -> f k v -> [(k, v)] -> TestTree
testcase
    String
nm
    (Query Int String
-> Query Int String
-> Fun (String -> String -> String)
-> Query Int String
forall k v.
Ord k =>
Query k v -> Query k v -> Fun (v -> v -> v) -> Query k v
OrD (BaseRep g Int String -> [(Int, String)] -> Query Int String
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep g Int String
rep [(Int, String)]
l1) (BaseRep g Int String -> [(Int, String)] -> Query Int String
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep g Int String
rep [(Int, String)]
l2) ((String -> String -> String) -> Fun (String -> String -> String)
forall a b c. (a -> b -> c) -> Fun (a -> b -> c)
lift (\String
x String
y -> String
x String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"-" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
y)))
    [ (Int
1, String
"a")
    , (Int
3, String
"c")
    , (Int
4, String
"d-d")
    , (Int
5, String
"e-e")
    , (Int
6, String
"f")
    , (Int
10, String
"j-j")
    , (Int
11, String
"k")
    , (Int
12, String
"l")
    , (Int
21, String
"v-v")
    , (Int
26, String
"z")
    ]
testDiff1 :: forall (g :: * -> * -> *).
Iter g =>
String -> BaseRep g Int String -> TestTree
testDiff1 String
nm BaseRep g Int String
rep =
  String -> Query Int String -> [(Int, String)] -> TestTree
forall k v (f :: * -> * -> *).
(Eq k, Eq v, Show k, Show v, Iter f) =>
String -> f k v -> [(k, v)] -> TestTree
testcase
    String
nm
    (Query Int String -> Query Int String -> Query Int String
forall k v u. Ord k => Query k v -> Query k u -> Query k v
DiffD (BaseRep g Int String -> [(Int, String)] -> Query Int String
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep g Int String
rep [(Int, String)]
l1) (BaseRep g Int String -> [(Int, String)] -> Query Int String
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep g Int String
rep [(Int, String)]
l2))
    [(Int
1, String
"a"), (Int
12, String
"l"), (Int
26, String
"z")]
testDiff2 :: forall (g :: * -> * -> *).
Iter g =>
String -> BaseRep g Int String -> TestTree
testDiff2 String
nm BaseRep g Int String
rep = String -> Query Int String -> [(Int, String)] -> TestTree
forall k v (f :: * -> * -> *).
(Eq k, Eq v, Show k, Show v, Iter f) =>
String -> f k v -> [(k, v)] -> TestTree
testcase String
nm (Query Int String -> Query Int String -> Query Int String
forall k v u. Ord k => Query k v -> Query k u -> Query k v
DiffD (BaseRep g Int String -> [(Int, String)] -> Query Int String
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep g Int String
rep [(Int, String)]
l2) (BaseRep g Int String -> [(Int, String)] -> Query Int String
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep g Int String
rep [(Int, String)]
l1)) [(Int
3, String
"c"), (Int
6, String
"f"), (Int
11, String
"k")]

-- ==========================================================================
-- tests where we vary both the data, and how it is represented.

testGuard :: (Show b, Iter f, Ord b) => String -> BaseRep f Int b -> [(Int, b)] -> TestTree
testGuard :: forall b (f :: * -> * -> *).
(Show b, Iter f, Ord b) =>
String -> BaseRep f Int b -> [(Int, b)] -> TestTree
testGuard String
nm BaseRep f Int b
rep [(Int, b)]
f =
  String -> Query Int b -> [(Int, b)] -> TestTree
forall k v (f :: * -> * -> *).
(Eq k, Eq v, Show k, Show v, Iter f) =>
String -> f k v -> [(k, v)] -> TestTree
testcase
    String
nm
    (Query Int b -> Fun (Int -> b -> Bool) -> Query Int b
forall k v. Ord k => Query k v -> Fun (k -> v -> Bool) -> Query k v
GuardD (BaseRep f Int b -> [(Int, b)] -> Query Int b
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep f Int b
rep [(Int, b)]
f) (Sett Int () -> Fun (Int -> b -> Bool)
forall dom (f :: * -> * -> *) v rng.
(Ord dom, Iter f) =>
f dom v -> Fun (dom -> rng -> Bool)
domElem Sett Int ()
evens))
    (((Int, b) -> Bool) -> [(Int, b)] -> [(Int, b)]
forall a. (a -> Bool) -> [a] -> [a]
filter (Int -> Bool
forall a. Integral a => a -> Bool
even (Int -> Bool) -> ((Int, b) -> Int) -> (Int, b) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int, b) -> Int
forall a b. (a, b) -> a
fst) [(Int, b)]
f)

testProj :: (Show k, Ord k, Iter f) => String -> BaseRep f k [Char] -> [(k, [Char])] -> TestTree
testProj :: forall k (f :: * -> * -> *).
(Show k, Ord k, Iter f) =>
String -> BaseRep f k String -> [(k, String)] -> TestTree
testProj String
nm BaseRep f k String
rep [(k, String)]
f =
  String -> Query k Int -> [(k, Int)] -> TestTree
forall k v (f :: * -> * -> *).
(Eq k, Eq v, Show k, Show v, Iter f) =>
String -> f k v -> [(k, v)] -> TestTree
testcase
    String
nm
    (Query k String -> Fun (k -> String -> Int) -> Query k Int
forall k v1 v.
Ord k =>
Query k v1 -> Fun (k -> v1 -> v) -> Query k v
ProjectD (BaseRep f k String -> [(k, String)] -> Query k String
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep f k String
rep [(k, String)]
f) ((k -> String -> Int) -> Fun (k -> String -> Int)
forall a b c. (a -> b -> c) -> Fun (a -> b -> c)
lift (\k
_x String
y -> Char -> Int
ord (String
y String -> Int -> Char
forall a. HasCallStack => [a] -> Int -> a
!! Int
0))))
    [(k
k, Char -> Int
ord (String
v String -> Int -> Char
forall a. HasCallStack => [a] -> Int -> a
!! Int
0)) | (k
k, String
v) <- [(k, String)]
f]

-- =============================================================================
-- tests where we AndP l1 and l3, and use different type of data for l1 from l3
-- We use the second projection in AndP, that is the value will come from l3

testAndP :: (Iter f, Iter g) => String -> BaseRep f Int String -> BaseRep g Int Int -> TestTree
testAndP :: forall (f :: * -> * -> *) (g :: * -> * -> *).
(Iter f, Iter g) =>
String -> BaseRep f Int String -> BaseRep g Int Int -> TestTree
testAndP String
nm BaseRep f Int String
rep1 BaseRep g Int Int
rep2 =
  String -> Query Int Int -> [(Int, Int)] -> TestTree
forall k v (f :: * -> * -> *).
(Eq k, Eq v, Show k, Show v, Iter f) =>
String -> f k v -> [(k, v)] -> TestTree
testcase
    String
nm
    (Query Int String
-> Query Int Int
-> Fun (Int -> (String, Int) -> Int)
-> Query Int Int
forall k v1 u v.
Ord k =>
Query k v1 -> Query k u -> Fun (k -> (v1, u) -> v) -> Query k v
AndPD (BaseRep f Int String -> [(Int, String)] -> Query Int String
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep f Int String
rep1 [(Int, String)]
l1) (BaseRep g Int Int -> [(Int, Int)] -> Query Int Int
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep g Int Int
rep2 [(Int, Int)]
l3) Fun (Int -> (String, Int) -> Int)
forall x a b. Fun (x -> (a, b) -> b)
rngSnd)
    [(Int
4, Int
12), (Int
12, Int
44)]

testChain :: (Iter f, Iter g) => String -> BaseRep f Int String -> BaseRep g String Int -> TestTree
testChain :: forall (f :: * -> * -> *) (g :: * -> * -> *).
(Iter f, Iter g) =>
String -> BaseRep f Int String -> BaseRep g String Int -> TestTree
testChain String
nm BaseRep f Int String
rep1 BaseRep g String Int
rep2 =
  String
-> Query Int (Int, String, Int)
-> [(Int, (Int, String, Int))]
-> TestTree
forall k v (f :: * -> * -> *).
(Eq k, Eq v, Show k, Show v, Iter f) =>
String -> f k v -> [(k, v)] -> TestTree
testcase
    String
nm
    (Query Int String
-> Query String Int
-> Fun (Int -> (String, Int) -> (Int, String, Int))
-> Query Int (Int, String, Int)
forall k v1 w v.
(Ord k, Ord v1) =>
Query k v1 -> Query v1 w -> Fun (k -> (v1, w) -> v) -> Query k v
ChainD (BaseRep f Int String -> [(Int, String)] -> Query Int String
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep f Int String
rep1 [(Int, String)]
l4) (BaseRep g String Int -> [(String, Int)] -> Query String Int
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep g String Int
rep2 [(String, Int)]
l5) ((Int -> (String, Int) -> (Int, String, Int))
-> Fun (Int -> (String, Int) -> (Int, String, Int))
forall a b c. (a -> b -> c) -> Fun (a -> b -> c)
lift (\Int
x (String
y, Int
v) -> (Int
x, String
y, Int
v))))
    [ (Int
1, (Int
1, String
"m", Int
105))
    , (Int
2, (Int
2, String
"a", Int
101))
    , (Int
6, (Int
6, String
"b", Int
102))
    , (Int
12, (Int
12, String
"w", Int
108))
    , (Int
50, (Int
50, String
"q", Int
107))
    ]

testChain2 :: (Iter f, Iter g) => String -> BaseRep f String Int -> BaseRep g Int String -> TestTree
testChain2 :: forall (f :: * -> * -> *) (g :: * -> * -> *).
(Iter f, Iter g) =>
String -> BaseRep f String Int -> BaseRep g Int String -> TestTree
testChain2 String
nm BaseRep f String Int
rep1 BaseRep g Int String
rep2 =
  String
-> Query String (String, Int, String)
-> [(String, (String, Int, String))]
-> TestTree
forall k v (f :: * -> * -> *).
(Eq k, Eq v, Show k, Show v, Iter f) =>
String -> f k v -> [(k, v)] -> TestTree
testcase
    String
nm
    (Query String Int
-> Query Int String
-> Fun (String -> (Int, String) -> (String, Int, String))
-> Query String (String, Int, String)
forall k v1 w v.
(Ord k, Ord v1) =>
Query k v1 -> Query v1 w -> Fun (k -> (v1, w) -> v) -> Query k v
ChainD (BaseRep f String Int -> [(String, Int)] -> Query String Int
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep f String Int
rep1 [(String, Int)]
l5) (BaseRep g Int String -> [(Int, String)] -> Query Int String
forall k (f :: * -> * -> *) v.
(Ord k, Iter f) =>
BaseRep f k v -> [(k, v)] -> Query k v
fromListD BaseRep g Int String
rep2 [(Int, String)]
l4) ((String -> (Int, String) -> (String, Int, String))
-> Fun (String -> (Int, String) -> (String, Int, String))
forall a b c. (a -> b -> c) -> Fun (a -> b -> c)
lift (\String
x (Int
y, String
v) -> (String
x, Int
y, String
v))))
    [(String
"m", (String
"m", Int
105, String
"Z"))]

-- This test inspired by set expression in EpochBoundary.hs
testEpochEx :: TestTree
testEpochEx :: TestTree
testEpochEx =
  String -> Assertion -> TestTree
testCase
    String
"Epoch Boundary Example"
    ( String -> Map Int Bool -> Map Int Bool -> Assertion
forall a.
(Eq a, Show a, HasCallStack) =>
String -> a -> a -> Assertion
assertEqual
        String
"Epoch Boundary Example"
        ([(Int, Bool)] -> Map Int Bool
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
6, Bool
True)])
        (Exp (Map Int Bool) -> Map Int Bool
forall s t. Embed s t => Exp t -> s
eval (Exp (Sett Int ()) -> Exp (Map Int Bool) -> Exp (Map Int Bool)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (Exp (Map Int String) -> Exp (Sett Int ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (Exp (Map Int String)
-> Exp (Single String ()) -> Exp (Map Int String)
forall k (g :: * -> * -> *) v (f :: * -> * -> *).
(Ord k, Iter g, Ord v) =>
Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
RRestrict (BaseRep Map Int String -> Map Int String -> Exp (Map Int String)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR Map Int String
delegs) (String -> Exp (Single String ())
forall k. Ord k => k -> Exp (Single k ())
SetSingleton String
hk))) (BaseRep Map Int Bool -> Map Int Bool -> Exp (Map Int Bool)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Int Bool
forall k v. Basic Map => BaseRep Map k v
MapR Map Int Bool
state)))
    )
  where
    delegs :: Map Int String
delegs = [(Int, String)] -> Map Int String
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
5 :: Int, String
"a"), (Int
6, String
"b"), (Int
12, String
"c"), (Int
14, String
"e"), (Int
20, String
"f"), (Int
25, String
"g")]
    hk :: String
hk = String
"b"
    state :: Map Int Bool
state = [(Int, Bool)] -> Map Int Bool
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Int
n, Int -> Bool
forall a. Integral a => a -> Bool
even Int
n) | Int
n <- [Int
1 .. Int
13]]

iterTests :: TestTree
iterTests :: TestTree
iterTests =
  String -> [TestTree] -> TestTree
testGroup
    String
"Iterator tests"
    [ String -> BaseRep List Int String -> TestTree
forall (g :: * -> * -> *).
Iter g =>
String -> BaseRep g Int String -> TestTree
testAnd1 String
"(And l1 l2) as List, fifo" BaseRep List Int String
forall k v. Basic List => BaseRep List k v
ListR
    , String -> BaseRep Map Int String -> TestTree
forall (g :: * -> * -> *).
Iter g =>
String -> BaseRep g Int String -> TestTree
testAnd1 String
"(And l1 l2) as Map, fifo" BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR
    , String -> BaseRep List Int String -> TestTree
forall (g :: * -> * -> *).
Iter g =>
String -> BaseRep g Int String -> TestTree
testAnd2 String
"(And l1 l2) as List, lifo" BaseRep List Int String
forall k v. Basic List => BaseRep List k v
ListR
    , String -> BaseRep Map Int String -> TestTree
forall (g :: * -> * -> *).
Iter g =>
String -> BaseRep g Int String -> TestTree
testAnd2 String
"(And l1 l2) as Map, lifo" BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR
    , String -> BaseRep List Int String -> TestTree
forall (g :: * -> * -> *).
Iter g =>
String -> BaseRep g Int String -> TestTree
testOr String
"(Or l1 l2) as List" BaseRep List Int String
forall k v. Basic List => BaseRep List k v
ListR
    , String -> BaseRep Map Int String -> TestTree
forall (g :: * -> * -> *).
Iter g =>
String -> BaseRep g Int String -> TestTree
testOr String
"(Or l1 l2) as Map" BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR
    , String -> BaseRep List Int String -> TestTree
forall (g :: * -> * -> *).
Iter g =>
String -> BaseRep g Int String -> TestTree
testDiff1 String
"(Diff l1 l2) as List" BaseRep List Int String
forall k v. Basic List => BaseRep List k v
ListR -- (Diff is not symmetric)
    , String -> BaseRep List Int String -> TestTree
forall (g :: * -> * -> *).
Iter g =>
String -> BaseRep g Int String -> TestTree
testDiff2 String
"(Diff l2 l1) as List" BaseRep List Int String
forall k v. Basic List => BaseRep List k v
ListR
    , String -> BaseRep Map Int String -> TestTree
forall (g :: * -> * -> *).
Iter g =>
String -> BaseRep g Int String -> TestTree
testDiff1 String
"(Diff l1 l2) as Map" BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR
    , String -> BaseRep Map Int String -> TestTree
forall (g :: * -> * -> *).
Iter g =>
String -> BaseRep g Int String -> TestTree
testDiff2 String
"(Diff l2 l1) as Map" BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR
    , String -> BaseRep List Int String -> [(Int, String)] -> TestTree
forall b (f :: * -> * -> *).
(Show b, Iter f, Ord b) =>
String -> BaseRep f Int b -> [(Int, b)] -> TestTree
testGuard String
"(Guard l1 even) as List" BaseRep List Int String
forall k v. Basic List => BaseRep List k v
ListR [(Int, String)]
l1
    , String -> BaseRep Map Int String -> [(Int, String)] -> TestTree
forall b (f :: * -> * -> *).
(Show b, Iter f, Ord b) =>
String -> BaseRep f Int b -> [(Int, b)] -> TestTree
testGuard String
"(Guard l1 even) as Map" BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR [(Int, String)]
l1
    , String -> BaseRep List Int String -> [(Int, String)] -> TestTree
forall b (f :: * -> * -> *).
(Show b, Iter f, Ord b) =>
String -> BaseRep f Int b -> [(Int, b)] -> TestTree
testGuard String
"(Guard l2 even) as List" BaseRep List Int String
forall k v. Basic List => BaseRep List k v
ListR [(Int, String)]
l2
    , String -> BaseRep Map Int String -> [(Int, String)] -> TestTree
forall b (f :: * -> * -> *).
(Show b, Iter f, Ord b) =>
String -> BaseRep f Int b -> [(Int, b)] -> TestTree
testGuard String
"(Guard l2 even) as Map" BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR [(Int, String)]
l2
    , String -> BaseRep List Int String -> [(Int, String)] -> TestTree
forall k (f :: * -> * -> *).
(Show k, Ord k, Iter f) =>
String -> BaseRep f k String -> [(k, String)] -> TestTree
testProj String
"(Proj l1 ord) as List" BaseRep List Int String
forall k v. Basic List => BaseRep List k v
ListR [(Int, String)]
l1
    , String -> BaseRep Map Int String -> [(Int, String)] -> TestTree
forall k (f :: * -> * -> *).
(Show k, Ord k, Iter f) =>
String -> BaseRep f k String -> [(k, String)] -> TestTree
testProj String
"(Proj l1 ord) as Map" BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR [(Int, String)]
l1
    , String -> BaseRep List Int String -> [(Int, String)] -> TestTree
forall k (f :: * -> * -> *).
(Show k, Ord k, Iter f) =>
String -> BaseRep f k String -> [(k, String)] -> TestTree
testProj String
"(Proj l2 ord) as List" BaseRep List Int String
forall k v. Basic List => BaseRep List k v
ListR [(Int, String)]
l2
    , String -> BaseRep Map Int String -> [(Int, String)] -> TestTree
forall k (f :: * -> * -> *).
(Show k, Ord k, Iter f) =>
String -> BaseRep f k String -> [(k, String)] -> TestTree
testProj String
"(Proj l2 ord) as Map" BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR [(Int, String)]
l2
    , String
-> BaseRep List Int String -> BaseRep Map Int Int -> TestTree
forall (f :: * -> * -> *) (g :: * -> * -> *).
(Iter f, Iter g) =>
String -> BaseRep f Int String -> BaseRep g Int Int -> TestTree
testAndP String
"(AndP l1:List l3:Map ord)" BaseRep List Int String
forall k v. Basic List => BaseRep List k v
ListR BaseRep Map Int Int
forall k v. Basic Map => BaseRep Map k v
MapR
    , String
-> BaseRep Map Int String -> BaseRep List Int Int -> TestTree
forall (f :: * -> * -> *) (g :: * -> * -> *).
(Iter f, Iter g) =>
String -> BaseRep f Int String -> BaseRep g Int Int -> TestTree
testAndP String
"(AndP l1:Map l3:List ord)" BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR BaseRep List Int Int
forall k v. Basic List => BaseRep List k v
ListR
    , String -> BaseRep Map Int String -> BaseRep Map Int Int -> TestTree
forall (f :: * -> * -> *) (g :: * -> * -> *).
(Iter f, Iter g) =>
String -> BaseRep f Int String -> BaseRep g Int Int -> TestTree
testAndP String
"(AndP l1:Map l3:List Map)" BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR BaseRep Map Int Int
forall k v. Basic Map => BaseRep Map k v
MapR
    , String
-> BaseRep List Int String -> BaseRep Map String Int -> TestTree
forall (f :: * -> * -> *) (g :: * -> * -> *).
(Iter f, Iter g) =>
String -> BaseRep f Int String -> BaseRep g String Int -> TestTree
testChain String
"(Chain l4:List l5:Map)" BaseRep List Int String
forall k v. Basic List => BaseRep List k v
ListR BaseRep Map String Int
forall k v. Basic Map => BaseRep Map k v
MapR
    , String
-> BaseRep Map Int String -> BaseRep List String Int -> TestTree
forall (f :: * -> * -> *) (g :: * -> * -> *).
(Iter f, Iter g) =>
String -> BaseRep f Int String -> BaseRep g String Int -> TestTree
testChain String
"(Chain l4:Map l5:List)" BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR BaseRep List String Int
forall k v. Basic List => BaseRep List k v
ListR
    , String
-> BaseRep Map Int String -> BaseRep Map String Int -> TestTree
forall (f :: * -> * -> *) (g :: * -> * -> *).
(Iter f, Iter g) =>
String -> BaseRep f Int String -> BaseRep g String Int -> TestTree
testChain String
"(Chain l4:Map l5:List Map)" BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR BaseRep Map String Int
forall k v. Basic Map => BaseRep Map k v
MapR
    , String
-> BaseRep List String Int -> BaseRep Map Int String -> TestTree
forall (f :: * -> * -> *) (g :: * -> * -> *).
(Iter f, Iter g) =>
String -> BaseRep f String Int -> BaseRep g Int String -> TestTree
testChain2 String
"(Chain2 l5:List l4:Map)" BaseRep List String Int
forall k v. Basic List => BaseRep List k v
ListR BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR
    , String
-> BaseRep Map String Int -> BaseRep List Int String -> TestTree
forall (f :: * -> * -> *) (g :: * -> * -> *).
(Iter f, Iter g) =>
String -> BaseRep f String Int -> BaseRep g Int String -> TestTree
testChain2 String
"(Chain2 l5:Map l4:List)" BaseRep Map String Int
forall k v. Basic Map => BaseRep Map k v
MapR BaseRep List Int String
forall k v. Basic List => BaseRep List k v
ListR
    , String
-> BaseRep Map String Int -> BaseRep Map Int String -> TestTree
forall (f :: * -> * -> *) (g :: * -> * -> *).
(Iter f, Iter g) =>
String -> BaseRep f String Int -> BaseRep g Int String -> TestTree
testChain2 String
"(Chain2 l5:Map l4:List Map)" BaseRep Map String Int
forall k v. Basic Map => BaseRep Map k v
MapR BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR
    , TestTree
testEpochEx
    ]

intersect2ways :: Map Int Char -> Map Int String -> Char -> Bool
intersect2ways :: Map Int Char -> Map Int String -> Char -> Bool
intersect2ways Map Int Char
delegs Map Int String
stake Char
hk =
  BaseRep Map Int String -> Collect (Int, String) -> Map Int String
forall k (f :: * -> * -> *) v.
Ord k =>
BaseRep f k v -> Collect (k, v) -> f k v
materialize BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR (do (Int
x, Char
y, String
z) <- Map Int Char
delegs Map Int Char -> Map Int String -> Collect (Int, Char, String)
forall k (f :: * -> * -> *) (g :: * -> * -> *) b c.
(Ord k, Iter f, Iter g) =>
f k b -> g k c -> Collect (k, b, c)
`domEq` Map Int String
stake; Bool -> Collect ()
when (Char
y Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
hk); (Int, String) -> Collect (Int, String)
forall t. t -> Collect t
one (Int
x, String
z))
    Map Int String -> Map Int String -> Bool
forall a. Eq a => a -> a -> Bool
== (Int -> Char -> Bool)
-> Map Int String -> Map Int Char -> Map Int String
forall k v2 v1.
Ord k =>
(k -> v2 -> Bool) -> Map k v1 -> Map k v2 -> Map k v1
intersectDomPLeft (\Int
_k Char
v2 -> Char
v2 Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
hk) Map Int String
stake Map Int Char
delegs

intersectDomPLeftTest :: TestTree
intersectDomPLeftTest :: TestTree
intersectDomPLeftTest = String
-> (Map Int Char -> Map Int String -> Char -> Bool) -> TestTree
forall a. Testable a => String -> a -> TestTree
testProperty String
"intersect2ways" Map Int Char -> Map Int String -> Char -> Bool
intersect2ways

ledgerStateProp :: Map Int Bool -> Map Int Char -> Map Char String -> Bool
ledgerStateProp :: Map Int Bool -> Map Int Char -> Map Char String -> Bool
ledgerStateProp Map Int Bool
xx Map Int Char
yy Map Char String
zz =
  BaseRep Map Int Char -> Collect (Int, Char) -> Map Int Char
forall k (f :: * -> * -> *) v.
Ord k =>
BaseRep f k v -> Collect (k, v) -> f k v
materialize BaseRep Map Int Char
forall k v. Basic Map => BaseRep Map k v
MapR (do (Int
x, Bool
_, Char
y) <- Map Int Bool
xx Map Int Bool -> Map Int Char -> Collect (Int, Bool, Char)
forall k (f :: * -> * -> *) (g :: * -> * -> *) b c.
(Ord k, Iter f, Iter g) =>
f k b -> g k c -> Collect (k, b, c)
`domEq` Map Int Char
yy; Char
y Char -> Map Char String -> Collect ()
forall k v. Ord k => k -> Map k v -> Collect ()
forall (f :: * -> * -> *) k v.
(Iter f, Ord k) =>
k -> f k v -> Collect ()
`element` Map Char String
zz; (Int, Char) -> Collect (Int, Char)
forall t. t -> Collect t
one (Int
x, Char
y))
    Map Int Char -> Map Int Char -> Bool
forall a. Eq a => a -> a -> Bool
== (Int -> Char -> Bool)
-> Map Int Bool -> Map Int Char -> Map Int Char
forall k v2 v1.
Ord k =>
(k -> v2 -> Bool) -> Map k v1 -> Map k v2 -> Map k v2
intersectDomP (\Int
_k Char
v -> Char -> Map Char String -> Bool
forall k a. Ord k => k -> Map k a -> Bool
Map.member Char
v Map Char String
zz) Map Int Bool
xx Map Int Char
yy

ledgerStateTest :: TestTree
ledgerStateTest :: TestTree
ledgerStateTest = String
-> (Map Int Bool -> Map Int Char -> Map Char String -> Bool)
-> TestTree
forall a. Testable a => String -> a -> TestTree
testProperty String
"ledgerStateExample2ways" Map Int Bool -> Map Int Char -> Map Char String -> Bool
ledgerStateProp

threeWay :: Map Int Char -> Map Int String -> Char -> Bool
threeWay :: Map Int Char -> Map Int String -> Char -> Bool
threeWay Map Int Char
delegs Map Int String
stake Char
hk =
  Exp (Map Int String) -> Map Int String
forall k (f :: * -> * -> *) v. Ord k => Exp (f k v) -> f k v
runSet (Exp (Map Int Char) -> Exp (Sett Int ())
forall k s (f :: * -> * -> *) v.
(Ord k, HasExp s (f k v)) =>
s -> Exp (Sett k ())
dom (Map Int Char
delegs Map Int Char -> Set Char -> Exp (Map Int Char)
forall k (g :: * -> * -> *) v s1 (f :: * -> * -> *) s2.
(Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) =>
s1 -> s2 -> Exp (f k v)
▷ Char -> Set Char
forall a. a -> Set a
Set.singleton Char
hk) Exp (Sett Int ()) -> Map Int String -> Exp (Map Int String)
forall k s1 s2 (f :: * -> * -> *) v.
(Ord k, HasExp s1 (Sett k ()), HasExp s2 (f k v)) =>
s1 -> s2 -> Exp (f k v)
◁ Map Int String
stake)
    Map Int String -> Map Int String -> Bool
forall a. Eq a => a -> a -> Bool
== (Int -> Char -> Bool)
-> Map Int String -> Map Int Char -> Map Int String
forall k v2 v1.
Ord k =>
(k -> v2 -> Bool) -> Map k v1 -> Map k v2 -> Map k v1
intersectDomPLeft (\Int
_k Char
v2 -> Char
v2 Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
hk) Map Int String
stake Map Int Char
delegs
    Bool -> Bool -> Bool
&& Exp (Map Int String) -> Map Int String
forall k (f :: * -> * -> *) v. Ord k => Exp (f k v) -> f k v
runSet (Exp (Map Int Char) -> Exp (Sett Int ())
forall k s (f :: * -> * -> *) v.
(Ord k, HasExp s (f k v)) =>
s -> Exp (Sett k ())
dom (Map Int Char
delegs Map Int Char -> Set Char -> Exp (Map Int Char)
forall k (g :: * -> * -> *) v s1 (f :: * -> * -> *) s2.
(Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) =>
s1 -> s2 -> Exp (f k v)
▷ Char -> Set Char
forall a. a -> Set a
Set.singleton Char
hk) Exp (Sett Int ()) -> Map Int String -> Exp (Map Int String)
forall k s1 s2 (f :: * -> * -> *) v.
(Ord k, HasExp s1 (Sett k ()), HasExp s2 (f k v)) =>
s1 -> s2 -> Exp (f k v)
◁ Map Int String
stake)
      Map Int String -> Map Int String -> Bool
forall a. Eq a => a -> a -> Bool
== BaseRep Map Int String -> Collect (Int, String) -> Map Int String
forall k (f :: * -> * -> *) v.
Ord k =>
BaseRep f k v -> Collect (k, v) -> f k v
materialize BaseRep Map Int String
forall k v. Basic Map => BaseRep Map k v
MapR (do (Int
x, Char
y, String
z) <- Map Int Char
delegs Map Int Char -> Map Int String -> Collect (Int, Char, String)
forall k (f :: * -> * -> *) (g :: * -> * -> *) b c.
(Ord k, Iter f, Iter g) =>
f k b -> g k c -> Collect (k, b, c)
`domEq` Map Int String
stake; Bool -> Collect ()
when (Char
y Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
hk); (Int, String) -> Collect (Int, String)
forall t. t -> Collect t
one (Int
x, String
z))

threeWayTest :: TestTree
threeWayTest :: TestTree
threeWayTest = String
-> (Map Int Char -> Map Int String -> Char -> Bool) -> TestTree
forall a. Testable a => String -> a -> TestTree
testProperty String
"eval-materialize-intersectDom" Map Int Char -> Map Int String -> Char -> Bool
threeWay

-- ==============================================================================
-- Slow property tests show that (compute e) and (runExp e) have the same answer.
-- The function (runExp), which uses compile, can be much slower than compute.
-- The reason for including (runExp) is that every query can be answered using
-- runExp, but only Queries which have data structure specific implementations
-- can use (compute). See the big case analysis in the function (compute).
-- ==============================================================================

-- Concrete types in the arbitrary monad to use to run slow tests.

newtype Key = Key Int
  deriving (Key -> Key -> Bool
(Key -> Key -> Bool) -> (Key -> Key -> Bool) -> Eq Key
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Key -> Key -> Bool
== :: Key -> Key -> Bool
$c/= :: Key -> Key -> Bool
/= :: Key -> Key -> Bool
Eq, Eq Key
Eq Key =>
(Key -> Key -> Ordering)
-> (Key -> Key -> Bool)
-> (Key -> Key -> Bool)
-> (Key -> Key -> Bool)
-> (Key -> Key -> Bool)
-> (Key -> Key -> Key)
-> (Key -> Key -> Key)
-> Ord Key
Key -> Key -> Bool
Key -> Key -> Ordering
Key -> Key -> Key
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Key -> Key -> Ordering
compare :: Key -> Key -> Ordering
$c< :: Key -> Key -> Bool
< :: Key -> Key -> Bool
$c<= :: Key -> Key -> Bool
<= :: Key -> Key -> Bool
$c> :: Key -> Key -> Bool
> :: Key -> Key -> Bool
$c>= :: Key -> Key -> Bool
>= :: Key -> Key -> Bool
$cmax :: Key -> Key -> Key
max :: Key -> Key -> Key
$cmin :: Key -> Key -> Key
min :: Key -> Key -> Key
Ord)

instance Show Key where
  show :: Key -> String
show (Key Int
n) = String
"k" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
n

-- ----------------------------
newtype Range = Range Int
  deriving (Range -> Range -> Bool
(Range -> Range -> Bool) -> (Range -> Range -> Bool) -> Eq Range
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Range -> Range -> Bool
== :: Range -> Range -> Bool
$c/= :: Range -> Range -> Bool
/= :: Range -> Range -> Bool
Eq, Eq Range
Eq Range =>
(Range -> Range -> Ordering)
-> (Range -> Range -> Bool)
-> (Range -> Range -> Bool)
-> (Range -> Range -> Bool)
-> (Range -> Range -> Bool)
-> (Range -> Range -> Range)
-> (Range -> Range -> Range)
-> Ord Range
Range -> Range -> Bool
Range -> Range -> Ordering
Range -> Range -> Range
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Range -> Range -> Ordering
compare :: Range -> Range -> Ordering
$c< :: Range -> Range -> Bool
< :: Range -> Range -> Bool
$c<= :: Range -> Range -> Bool
<= :: Range -> Range -> Bool
$c> :: Range -> Range -> Bool
> :: Range -> Range -> Bool
$c>= :: Range -> Range -> Bool
>= :: Range -> Range -> Bool
$cmax :: Range -> Range -> Range
max :: Range -> Range -> Range
$cmin :: Range -> Range -> Range
min :: Range -> Range -> Range
Ord, Integer -> Range
Range -> Range
Range -> Range -> Range
(Range -> Range -> Range)
-> (Range -> Range -> Range)
-> (Range -> Range -> Range)
-> (Range -> Range)
-> (Range -> Range)
-> (Range -> Range)
-> (Integer -> Range)
-> Num Range
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Range -> Range -> Range
+ :: Range -> Range -> Range
$c- :: Range -> Range -> Range
- :: Range -> Range -> Range
$c* :: Range -> Range -> Range
* :: Range -> Range -> Range
$cnegate :: Range -> Range
negate :: Range -> Range
$cabs :: Range -> Range
abs :: Range -> Range
$csignum :: Range -> Range
signum :: Range -> Range
$cfromInteger :: Integer -> Range
fromInteger :: Integer -> Range
Num)

instance Show Range where
  show :: Range -> String
show (Range Int
n) = Int -> String
forall a. Show a => a -> String
show Int
n

instance Semigroup Range where
  Range Int
x <> :: Range -> Range -> Range
<> Range Int
y = Int -> Range
Range (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
y)

instance Monoid Range where
  mempty :: Range
mempty = Int -> Range
Range Int
0

-- ===========================================================
-- helper functions to construct related types and Properties.

flipRng :: (Ord b, Num b) => List a b -> List b b
flipRng :: forall b a. (Ord b, Num b) => List a b -> List b b
flipRng (UnSafeList [(a, b)]
xs) = (b -> b -> b) -> [(b, b)] -> List b b
forall k v. Ord k => (v -> v -> v) -> [(k, v)] -> List k v
fromPairs b -> b -> b
forall a. Num a => a -> a -> a
(+) (((a, b) -> (b, b)) -> [(a, b)] -> [(b, b)]
forall a b. (a -> b) -> [a] -> [b]
map (\(a
_a, b
b) -> (b
b, b
b)) [(a, b)]
xs)

duplicate :: Ord a => Set.Set a -> Map.Map a a
duplicate :: forall a. Ord a => Set a -> Map a a
duplicate Set a
s = (a -> Map a a -> Map a a) -> Map a a -> Set a -> Map a a
forall a b. (a -> b -> b) -> b -> Set a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\a
a Map a a
m -> a -> a -> Map a a -> Map a a
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert a
a a
a Map a a
m) Map a a
forall k a. Map k a
Map.empty Set a
s

btest :: Exp Bool -> Property
btest :: Exp Bool -> Property
btest Exp Bool
expr = Exp Bool -> Bool
forall t. Exp t -> t
compute Exp Bool
expr Bool -> Bool -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== Exp Bool -> Bool
runBool Exp Bool
expr

qtest :: (Ord key, Eq (f key a), Show (f key a)) => Exp (f key a) -> Property
qtest :: forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest Exp (f key a)
expr = Exp (f key a) -> f key a
forall t. Exp t -> t
compute Exp (f key a)
expr f key a -> f key a -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== Exp (f key a) -> f key a
forall k (f :: * -> * -> *) v. Ord k => Exp (f k v) -> f k v
runSet Exp (f key a)
expr

-- ======================================================

slowFastEquiv :: TestTree
slowFastEquiv :: TestTree
slowFastEquiv = String
-> (Key
    -> Range
    -> Map Key Range
    -> Map Key Range
    -> Set Key
    -> Set Key
    -> Set Range
    -> List Key Range
    -> Property)
-> TestTree
forall a. Testable a => String -> a -> TestTree
testProperty String
"slowFastEquiv" Key
-> Range
-> Map Key Range
-> Map Key Range
-> Set Key
-> Set Key
-> Set Range
-> List Key Range
-> Property
slowProperties

slowProperties ::
  Key -> -- k
  Range -> -- v
  Map Key Range -> -- m1
  Map Key Range -> -- m2
  Set.Set Key -> -- s1
  Set.Set Key -> -- s2
  Set.Set Range -> -- rs
  List Key Range -> -- ls
  Property
slowProperties :: Key
-> Range
-> Map Key Range
-> Map Key Range
-> Set Key
-> Set Key
-> Set Range
-> List Key Range
-> Property
slowProperties Key
k Range
v Map Key Range
m1 Map Key Range
m2 Set Key
s1 Set Key
s2 Set Range
rs List Key Range
ls =
  [Property] -> Property
forall prop. Testable prop => [prop] -> Property
conjoin ([Property] -> Property) -> [Property] -> Property
forall a b. (a -> b) -> a -> b
$
    ((Property, String) -> Property)
-> [(Property, String)] -> [Property]
forall a b. (a -> b) -> [a] -> [b]
map
      (\(Property
prop, String
name) -> String -> Property -> Property
forall prop. Testable prop => String -> prop -> Property
counterexample String
name Property
prop)
      [ (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1))), String
"slow1")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)), String
"slow2")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1))), String
"slow3")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)), String
"slow4")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Single Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (Key -> Range -> Exp (Single Key Range)
forall k v. Ord k => k -> v -> Exp (Single k v)
Singleton Key
k Range
v)), String
"slow5")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Single Key ()) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (Key -> Exp (Single Key ())
forall k. Ord k => k -> Exp (Single k ())
SetSingleton Key
k)), String
"slow6")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)), String
"slow7")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (Exp (Map Key Range) -> Exp (Single Range ()) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) v (f :: * -> * -> *).
(Ord k, Iter g, Ord v) =>
Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
RRestrict (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (Range -> Exp (Single Range ())
forall k. Ord k => k -> Exp (Single k ())
SetSingleton Range
v))), String
"slow8")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (Exp (Map Key Range) -> Exp (Sett Range ()) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) v (f :: * -> * -> *).
(Ord k, Iter g, Ord v) =>
Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
RRestrict (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (BaseRep Sett Range () -> Sett Range () -> Exp (Sett Range ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Range ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Range -> Sett Range ()
forall k. Set k -> Sett k ()
Sett Set Range
rs)))), String
"slow9")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (Exp (Map Key Range) -> Exp (Single Range ()) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) v (f :: * -> * -> *).
(Ord k, Iter g, Ord v) =>
Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
RExclude (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (Range -> Exp (Single Range ())
forall k. Ord k => k -> Exp (Single k ())
SetSingleton Range
v))), String
"slow10")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (Exp (Map Key Range) -> Exp (Sett Range ()) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) v (f :: * -> * -> *).
(Ord k, Iter g, Ord v) =>
Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
RExclude (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (BaseRep Sett Range () -> Sett Range () -> Exp (Sett Range ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Range ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Range -> Sett Range ()
forall k. Set k -> Sett k ()
Sett Set Range
rs)))), String
"slow11")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (Exp (Single Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (Key -> Exp (Single Key ())
forall k. Ord k => k -> Exp (Single k ())
SetSingleton Key
k) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1))), String
"slow12")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (Exp (Sett Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1))), String
"slow13")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (Exp (Single Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DExclude (Key -> Exp (Single Key ())
forall k. Ord k => k -> Exp (Single k ())
SetSingleton Key
k) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1))), String
"slow14")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (Exp (Sett Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DExclude (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1))), String
"slow15")
      , (Exp (Sett () ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Sett () ())
forall k v (f :: * -> * -> *).
(Ord k, Ord v) =>
Exp (f k v) -> Exp (Sett v ())
Rng (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1))), String
"slow16")
      , (Exp (Sett Range ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Single Key Range) -> Exp (Sett Range ())
forall k v (f :: * -> * -> *).
(Ord k, Ord v) =>
Exp (f k v) -> Exp (Sett v ())
Rng (Key -> Range -> Exp (Single Key Range)
forall k v. Ord k => k -> v -> Exp (Single k v)
Singleton Key
k Range
v)), String
"slow17")
      , (Exp (Sett () ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Single Key ()) -> Exp (Sett () ())
forall k v (f :: * -> * -> *).
(Ord k, Ord v) =>
Exp (f k v) -> Exp (Sett v ())
Rng (Key -> Exp (Single Key ())
forall k. Ord k => k -> Exp (Single k ())
SetSingleton Key
k)), String
"slow18")
      , (Exp (Sett Range ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Sett Range ())
forall k v (f :: * -> * -> *).
(Ord k, Ord v) =>
Exp (f k v) -> Exp (Sett v ())
Rng (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)), String
"slow19")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)), String
"slow21")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Single Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (Key -> Exp (Single Key ())
forall k. Ord k => k -> Exp (Single k ())
SetSingleton Key
k) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)), String
"slow22")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Single Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (Key -> () -> Exp (Single Key ())
forall k v. Ord k => k -> v -> Exp (Single k v)
Singleton Key
k ()) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)), String
"slow23")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2)) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)), String
"slow24")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (Exp (Map Key Range) -> Exp (Single Range ()) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) v (f :: * -> * -> *).
(Ord k, Iter g, Ord v) =>
Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
RRestrict (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (Range -> Exp (Single Range ())
forall k. Ord k => k -> Exp (Single k ())
SetSingleton Range
v))) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2)), String
"slow25")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (Exp (Map Key Range) -> Exp (Sett Range ()) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) v (f :: * -> * -> *).
(Ord k, Iter g, Ord v) =>
Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
RRestrict (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (BaseRep Sett Range () -> Sett Range () -> Exp (Sett Range ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Range ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Range -> Sett Range ()
forall k. Set k -> Sett k ()
Sett Set Range
rs)))) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2)), String
"slow26")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)), String
"slow27")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp (Sett Key ())
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s2))), String
"slow28")
      , (Exp (List Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (List Key Range) -> Exp (List Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep List Key Range -> List Key Range -> Exp (List Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep List Key Range
forall k v. Basic List => BaseRep List k v
ListR List Key Range
ls)), String
"slow29")
      , (Exp (List Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (List Key Range) -> Exp (List Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)) (BaseRep List Key Range -> List Key Range -> Exp (List Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep List Key Range
forall k v. Basic List => BaseRep List k v
ListR List Key Range
ls)), String
"slow30")
      , (Exp (List Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Single Key ()) -> Exp (List Key Range) -> Exp (List Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (Key -> Exp (Single Key ())
forall k. Ord k => k -> Exp (Single k ())
SetSingleton Key
k) (BaseRep List Key Range -> List Key Range -> Exp (List Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep List Key Range
forall k v. Basic List => BaseRep List k v
ListR List Key Range
ls)), String
"slow31")
      , (Exp (List Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (List Key Range) -> Exp (List Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (Exp (Single Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (Key -> Range -> Exp (Single Key Range)
forall k v. Ord k => k -> v -> Exp (Single k v)
Singleton Key
k Range
v)) (BaseRep List Key Range -> List Key Range -> Exp (List Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep List Key Range
forall k v. Basic List => BaseRep List k v
ListR List Key Range
ls)), String
"slow32")
      , (Exp (List Range Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Range ())
-> Exp (List Range Range) -> Exp (List Range Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (Exp (Single Key Range) -> Exp (Sett Range ())
forall k v (f :: * -> * -> *).
(Ord k, Ord v) =>
Exp (f k v) -> Exp (Sett v ())
Rng (Key -> Range -> Exp (Single Key Range)
forall k v. Ord k => k -> v -> Exp (Single k v)
Singleton Key
k Range
v)) (BaseRep List Range Range
-> List Range Range -> Exp (List Range Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep List Range Range
forall k v. Basic List => BaseRep List k v
ListR (List Key Range -> List Range Range
forall b a. (Ord b, Num b) => List a b -> List b b
flipRng List Key Range
ls))), String
"slow33")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Single Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DExclude (Key -> Exp (Single Key ())
forall k. Ord k => k -> Exp (Single k ())
SetSingleton Key
k) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)), String
"slow35")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DExclude (Exp (Single Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (Key -> Range -> Exp (Single Key Range)
forall k v. Ord k => k -> v -> Exp (Single k v)
Singleton Key
k Range
v)) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)), String
"slow36")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DExclude (Exp (Single Range Key) -> Exp (Sett Key ())
forall k v (f :: * -> * -> *).
(Ord k, Ord v) =>
Exp (f k v) -> Exp (Sett v ())
Rng (Range -> Key -> Exp (Single Range Key)
forall k v. Ord k => k -> v -> Exp (Single k v)
Singleton Range
v Key
k)) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)), String
"slow37")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DExclude (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)), String
"slow38")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DExclude (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2)), String
"slow39")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Sett Range ()) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) v (f :: * -> * -> *).
(Ord k, Iter g, Ord v) =>
Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
RExclude (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (BaseRep Sett Range () -> Sett Range () -> Exp (Sett Range ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Range ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Range -> Sett Range ()
forall k. Set k -> Sett k ()
Sett Set Range
rs))), String
"slow47")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Single Range ()) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) v (f :: * -> * -> *).
(Ord k, Iter g, Ord v) =>
Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
RExclude (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (Range -> Exp (Single Range ())
forall k. Ord k => k -> Exp (Single k ())
SetSingleton Range
v)), String
"slow48")
      , (Exp (List Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (List Key Range) -> Exp (Sett Range ()) -> Exp (List Key Range)
forall k (g :: * -> * -> *) v (f :: * -> * -> *).
(Ord k, Iter g, Ord v) =>
Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
RExclude (BaseRep List Key Range -> List Key Range -> Exp (List Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep List Key Range
forall k v. Basic List => BaseRep List k v
ListR List Key Range
ls) (BaseRep Sett Range () -> Sett Range () -> Exp (Sett Range ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Range ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Range -> Sett Range ()
forall k. Set k -> Sett k ()
Sett Set Range
rs))), String
"slow49")
      , (Exp (List Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (List Key Range)
-> Exp (Single Range ()) -> Exp (List Key Range)
forall k (g :: * -> * -> *) v (f :: * -> * -> *).
(Ord k, Iter g, Ord v) =>
Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
RExclude (BaseRep List Key Range -> List Key Range -> Exp (List Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep List Key Range
forall k v. Basic List => BaseRep List k v
ListR List Key Range
ls) (BaseRep Single Range () -> Single Range () -> Exp (Single Range ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Single Range ()
forall k v. Basic Single => BaseRep Single k v
SingleR Single Range ()
forall k v. Single k v
Fail)), String
"slow50")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Single Range ()) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) v (f :: * -> * -> *).
(Ord k, Iter g, Ord v) =>
Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
RRestrict (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (Range -> Exp (Single Range ())
forall k. Ord k => k -> Exp (Single k ())
SetSingleton Range
v)), String
"slow52")
      ,
        ( Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Sett Range ()) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) v (f :: * -> * -> *).
(Ord k, Iter g, Ord v) =>
Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
RRestrict (Exp (Sett Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)) (Exp (Map Range Range) -> Exp (Sett Range ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Range Range -> Map Range Range -> Exp (Map Range Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Range Range
forall k v. Basic Map => BaseRep Map k v
MapR (Set Range -> Map Range Range
forall a. Ord a => Set a -> Map a a
duplicate Set Range
rs))))
        , String
"slow53"
        )
      ,
        ( Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Sett Range ()) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) v (f :: * -> * -> *).
(Ord k, Iter g, Ord v) =>
Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
RRestrict (Exp (Sett Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2)) (Exp (List Range Range) -> Exp (Sett Range ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep List Range Range
-> List Range Range -> Exp (List Range Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep List Range Range
forall k v. Basic List => BaseRep List k v
ListR (List Key Range -> List Range Range
forall b a. (Ord b, Num b) => List a b -> List b b
flipRng List Key Range
ls))))
        , String
"slow54"
        )
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
Elem Key
k (Exp (List Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep List Key Range -> List Key Range -> Exp (List Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep List Key Range
forall k v. Basic List => BaseRep List k v
ListR List Key Range
ls))), String
"slow56")
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
Elem Key
k (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1))), String
"slow57")
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
Elem Key
k (Exp (Single Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (Key -> Range -> Exp (Single Key Range)
forall k v. Ord k => k -> v -> Exp (Single k v)
Singleton Key
k Range
v))), String
"slow58")
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
Elem Key
k (Exp (Single Range Key) -> Exp (Sett Key ())
forall k v (f :: * -> * -> *).
(Ord k, Ord v) =>
Exp (f k v) -> Exp (Sett v ())
Rng (Range -> Key -> Exp (Single Range Key)
forall k v. Ord k => k -> v -> Exp (Single k v)
Singleton Range
v Key
k))), String
"slow59")
      , (Exp Bool -> Property
btest (Key -> Exp (Single Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
Elem Key
k (Key -> Exp (Single Key ())
forall k. Ord k => k -> Exp (Single k ())
SetSingleton Key
k)), String
"slow60")
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
Elem Key
k (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp (Sett Key ())
forall k v (f :: * -> * -> *) (g :: * -> * -> *).
(Show k, Show v, Ord k) =>
Exp (f k v) -> Exp (g k v) -> Exp (f k v)
UnionOverrideLeft (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s2)))), String
"slow61")
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
Elem Key
k (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v (g :: * -> * -> *).
Ord k =>
Exp (f k v) -> Exp (g k v) -> Exp (f k v)
UnionOverrideRight (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s2)))), String
"slow62")
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
Elem Key
k (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp (Sett Key ())
forall k n (f :: * -> * -> *) (g :: * -> * -> *).
(Ord k, Monoid n) =>
Exp (f k n) -> Exp (g k n) -> Exp (f k n)
UnionPlus (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s2)))), String
"slow63")
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
Elem Key
k (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp (Sett k ())
Intersect (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s2)))), String
"slow64")
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
Elem Key
k (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp (Sett Key ())
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DRestrict (Exp (Sett Key ()) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1))) (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)))), String
"slow106")
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
Elem Key
k (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp (Sett Key ())
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DExclude (Exp (Sett Key ()) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1))) (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)))), String
"slow107")
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
NotElem Key
k (Exp (List Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep List Key Range -> List Key Range -> Exp (List Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep List Key Range
forall k v. Basic List => BaseRep List k v
ListR List Key Range
ls))), String
"slow66")
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
NotElem Key
k (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1))), String
"slow67")
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
NotElem Key
k (Exp (Single Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (Key -> Range -> Exp (Single Key Range)
forall k v. Ord k => k -> v -> Exp (Single k v)
Singleton Key
k Range
v))), String
"slow68")
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
NotElem Key
k (Exp (Single Range Key) -> Exp (Sett Key ())
forall k v (f :: * -> * -> *).
(Ord k, Ord v) =>
Exp (f k v) -> Exp (Sett v ())
Rng (Range -> Key -> Exp (Single Range Key)
forall k v. Ord k => k -> v -> Exp (Single k v)
Singleton Range
v Key
k))), String
"slow69")
      , (Exp Bool -> Property
btest (Key -> Exp (Single Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
NotElem Key
k (Key -> Exp (Single Key ())
forall k. Ord k => k -> Exp (Single k ())
SetSingleton Key
k)), String
"slow70")
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
NotElem Key
k (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp (Sett Key ())
forall k v (f :: * -> * -> *) (g :: * -> * -> *).
(Show k, Show v, Ord k) =>
Exp (f k v) -> Exp (g k v) -> Exp (f k v)
UnionOverrideLeft (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s2)))), String
"slow71")
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
NotElem Key
k (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v (g :: * -> * -> *).
Ord k =>
Exp (f k v) -> Exp (g k v) -> Exp (f k v)
UnionOverrideRight (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s2)))), String
"slow72")
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
NotElem Key
k (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp (Sett Key ())
forall k n (f :: * -> * -> *) (g :: * -> * -> *).
(Ord k, Monoid n) =>
Exp (f k n) -> Exp (g k n) -> Exp (f k n)
UnionPlus (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s2)))), String
"slow73")
      , (Exp Bool -> Property
btest (Key -> Exp (Sett Key ()) -> Exp Bool
forall k (g :: * -> * -> *).
(Ord k, Iter g, Show k) =>
k -> Exp (g k ()) -> Exp Bool
NotElem Key
k (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp (Sett k ())
Intersect (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s2)))), String
"slow74")
      , (Exp Bool -> Property
btest (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp Bool
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp Bool
Subset (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s2))), String
"slow76")
      , (Exp Bool -> Property
btest (Exp (Sett Key ()) -> Exp (Map Key Range) -> Exp Bool
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp Bool
Subset (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)), String
"slow77")
      , (Exp Bool -> Property
btest (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp Bool
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp Bool
Subset (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1))), String
"slow78")
      , (Exp Bool -> Property
btest (Exp (Map Key Range) -> Exp (Map Key Range) -> Exp Bool
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp Bool
Subset (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2)), String
"slow79")
      , (Exp Bool -> Property
btest (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp Bool
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp Bool
Subset (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)) (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2))), String
"slow80")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp (Sett k ())
Intersect (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s2))), String
"slow82")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp (Sett k ())
Intersect (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2)), String
"slow83")
      , (Exp (List Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (List Key Range)
-> Exp (Single Key Range) -> Exp (List Key Range)
forall k v (f :: * -> * -> *) (g :: * -> * -> *).
(Show k, Show v, Ord k) =>
Exp (f k v) -> Exp (g k v) -> Exp (f k v)
UnionOverrideLeft (BaseRep List Key Range -> List Key Range -> Exp (List Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep List Key Range
forall k v. Basic List => BaseRep List k v
ListR List Key Range
ls) (Key -> Range -> Exp (Single Key Range)
forall k v. Ord k => k -> v -> Exp (Single k v)
Singleton Key
k Range
v)), String
"slow85")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k v (f :: * -> * -> *) (g :: * -> * -> *).
(Show k, Show v, Ord k) =>
Exp (f k v) -> Exp (g k v) -> Exp (f k v)
UnionOverrideLeft (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2)), String
"slow86")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp (Sett Key ())
forall k v (f :: * -> * -> *) (g :: * -> * -> *).
(Show k, Show v, Ord k) =>
Exp (f k v) -> Exp (g k v) -> Exp (f k v)
UnionOverrideLeft (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s2))), String
"slow87")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k v (f :: * -> * -> *) (g :: * -> * -> *).
(Show k, Show v, Ord k) =>
Exp (f k v) -> Exp (g k v) -> Exp (f k v)
UnionOverrideLeft (Exp (Single Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DExclude (Key -> Exp (Single Key ())
forall k. Ord k => k -> Exp (Single k ())
SetSingleton Key
k) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2)), String
"slow88")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k v (f :: * -> * -> *) (g :: * -> * -> *).
(Show k, Show v, Ord k) =>
Exp (f k v) -> Exp (g k v) -> Exp (f k v)
UnionOverrideLeft (Exp (Sett Key ()) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (g :: * -> * -> *) (f :: * -> * -> *) v.
(Ord k, Iter g) =>
Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DExclude (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2)), String
"slow89")
      , (Exp (List Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (List Key Range)
-> Exp (Single Key Range) -> Exp (List Key Range)
forall k (f :: * -> * -> *) v (g :: * -> * -> *).
Ord k =>
Exp (f k v) -> Exp (g k v) -> Exp (f k v)
UnionOverrideRight (BaseRep List Key Range -> List Key Range -> Exp (List Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep List Key Range
forall k v. Basic List => BaseRep List k v
ListR List Key Range
ls) (Key -> Range -> Exp (Single Key Range)
forall k v. Ord k => k -> v -> Exp (Single k v)
Singleton Key
k Range
v)), String
"slow91")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v (g :: * -> * -> *).
Ord k =>
Exp (f k v) -> Exp (g k v) -> Exp (f k v)
UnionOverrideRight (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2)), String
"slow92")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v (g :: * -> * -> *).
Ord k =>
Exp (f k v) -> Exp (g k v) -> Exp (f k v)
UnionOverrideRight (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s2))), String
"slow93")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k n (f :: * -> * -> *) (g :: * -> * -> *).
(Ord k, Monoid n) =>
Exp (f k n) -> Exp (g k n) -> Exp (f k n)
UnionPlus (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2)), String
"slow95")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp (Sett Key ())
forall k n (f :: * -> * -> *) (g :: * -> * -> *).
(Ord k, Monoid n) =>
Exp (f k n) -> Exp (g k n) -> Exp (f k n)
UnionPlus (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s2))), String
"slow96")
      , (Exp (Single Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Key -> Range -> Exp (Single Key Range)
forall k v. Ord k => k -> v -> Exp (Single k v)
Singleton Key
k Range
v), String
"slow98")
      , (Exp (Single Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Key -> Exp (Single Key ())
forall k. Ord k => k -> Exp (Single k ())
SetSingleton Key
k), String
"slow99")
      , (Exp Bool -> Property
btest (Exp (Map Key Range) -> Exp (Map Key Range) -> Exp Bool
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp Bool
KeyEqual (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2)), String
"slow100")
      , (Exp Bool -> Property
btest (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp Bool
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp Bool
KeyEqual (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1)) (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2))), String
"slow102")
      , (Exp Bool -> Property
btest (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp Bool
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp Bool
KeyEqual (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s2))), String
"slow104")
      , (Exp Bool -> Property
btest (Exp (Map Key Range) -> Exp (Sett Key ()) -> Exp Bool
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp Bool
KeyEqual (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1))), String
"slow105")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp (f k v)
SetDiff (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s2))), String
"slow108")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp (f k v)
SetDiff (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2)), String
"slow109")
      , (Exp (Sett Key ()) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Sett Key ()) -> Exp (Sett Key ()) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp (f k v)
SetDiff (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s1)) (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2))), String
"slow110")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Sett Key ()) -> Exp (Map Key Range)
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp (f k v)
SetDiff (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (Exp (Map Key Range) -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
Ord k =>
Exp (f k v) -> Exp (Sett k ())
Dom (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2))), String
"slow111")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Map Key Range) -> Exp (Map Key Range)
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp (f k v)
SetDiff (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m2)), String
"slow112")
      , (Exp (Map Key Range) -> Property
forall key (f :: * -> * -> *) a.
(Ord key, Eq (f key a), Show (f key a)) =>
Exp (f key a) -> Property
qtest (Exp (Map Key Range) -> Exp (Sett Key ()) -> Exp (Map Key Range)
forall k (f :: * -> * -> *) (g :: * -> * -> *) v u.
(Ord k, Iter f, Iter g) =>
Exp (f k v) -> Exp (g k u) -> Exp (f k v)
SetDiff (BaseRep Map Key Range -> Map Key Range -> Exp (Map Key Range)
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map Key Range
forall k v. Basic Map => BaseRep Map k v
MapR Map Key Range
m1) (BaseRep Sett Key () -> Sett Key () -> Exp (Sett Key ())
forall k (f :: * -> * -> *) v.
(Ord k, Basic f, Iter f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Sett Key ()
forall k. Basic Sett => BaseRep Sett k ()
SetR (Set Key -> Sett Key ()
forall k. Set k -> Sett k ()
Sett Set Key
s2))), String
"slow113")
      ]

-- ==================================================
-- Arbitrary instances for the slow tests.

-- | Sizes should favor middle sized numbers
genSize :: Gen Int
genSize :: Gen Int
genSize =
  [(Int, Gen Int)] -> Gen Int
forall a. HasCallStack => [(Int, Gen a)] -> Gen a
frequency
    [ (Int
1, Int -> Gen Int
forall a. a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
0)
    , (Int
2, Int -> Gen Int
forall a. a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
1)
    , (Int
5, Int -> Gen Int
forall a. a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
2)
    , (Int
5, Int -> Gen Int
forall a. a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
3)
    , (Int
4, Int -> Gen Int
forall a. a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
4)
    , (Int
3, Int -> Gen Int
forall a. a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
5)
    , (Int
2, Int -> Gen Int
forall a. a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
6)
    , (Int
1, Int -> Gen Int
forall a. a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
7)
    ]

-- | Keep the set of Key and Range pretty small so Maps share keys
instance Arbitrary Key where
  arbitrary :: Gen Key
arbitrary = (Int -> Key) -> Gen Int -> Gen Key
forall a b. (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> Key
Key ((Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
1, Int
12))

-- | The Range type can have a slightly larger set
instance Arbitrary Range where
  arbitrary :: Gen Range
arbitrary = (Int -> Range) -> Gen Int -> Gen Range
forall a b. (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> Range
Range ((Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
1, Int
20))

instance (Ord k, Arbitrary k, Arbitrary v) => Arbitrary (List k v) where
  arbitrary :: Gen (List k v)
arbitrary = do
    Int
n <- Gen Int
genSize
    [(k, v)]
xs <- Int -> Gen (k, v) -> Gen [(k, v)]
forall a. Int -> Gen a -> Gen [a]
vectorOf Int
n Gen (k, v)
forall a. Arbitrary a => Gen a
arbitrary
    List k v -> Gen (List k v)
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (List k v -> Gen (List k v)) -> List k v -> Gen (List k v)
forall a b. (a -> b) -> a -> b
$ (v -> v -> v) -> [(k, v)] -> List k v
forall k v. Ord k => (v -> v -> v) -> [(k, v)] -> List k v
fromPairs (\v
_old v
new -> v
new) [(k, v)]
xs

instance (Ord k, Arbitrary k) => Arbitrary (Sett k ()) where
  arbitrary :: Gen (Sett k ())
arbitrary = do
    Int
n <- Gen Int
genSize
    [k]
xs <- Int -> Gen k -> Gen [k]
forall a. Int -> Gen a -> Gen [a]
vectorOf Int
n Gen k
forall a. Arbitrary a => Gen a
arbitrary
    Sett k () -> Gen (Sett k ())
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Set k -> Sett k ()
forall k. Set k -> Sett k ()
Sett ([k] -> Set k
forall a. Ord a => [a] -> Set a
Set.fromList [k]
xs))

-- ====================================================
-- Tie all the tests together
-- ====================================================

setAlgTest :: TestTree
setAlgTest :: TestTree
setAlgTest =
  String -> [TestTree] -> TestTree
testGroup
    String
"Set Algebra Tests"
    [ TestTree
evalTests
    , TestTree
keysEqTests
    , TestTree
iterTests
    , TestTree
intersectDomPLeftTest
    , TestTree
ledgerStateTest
    , TestTree
threeWayTest
    , TestTree
slowFastEquiv
    ]