module Data.Interval.Borel (
  Borel (Borel),
  borel,
  intervalSet,
  Data.Interval.Borel.empty,
  singleton,
  Data.Interval.Borel.null,
  insert,
  whole,
  remove,
  (\-),
  truncate,
  (\=),
  member,
  notMember,
  union,
  unions,
  difference,
  symmetricDifference,
  complement,
  intersection,
  intersections,
  hull,
  isSubsetOf,
  Shrink (..),
) where

import Algebra.Heyting (Heyting ((==>)))
import Algebra.Lattice (
  BoundedJoinSemiLattice (..),
  BoundedMeetSemiLattice (..),
  Lattice (..),
 )
import Algebra.Lattice.Levitated (Levitated (..))
import Data.Data (Data, Typeable)
import Data.Foldable (fold)
import Data.Functor ((<&>))
import Data.Interval (Interval)
import Data.Interval qualified as I
import Data.List.NonEmpty (NonEmpty ((:|)))
import Data.OneOrTwo (OneOrTwo (..))
import Data.Semiring (Ring, Semiring)
import Data.Semiring qualified as Semiring
import Data.Set (Set)
import Data.Set qualified as Set
import GHC.Generics (Generic)
import Prelude hiding (null, truncate)

-- | The 'Borel' sets on a type are the sets generated by its intervals.
-- It forms a 'Heyting' algebra with 'union' as join and 'intersection' as meet,
-- and a 'Ring' with 'symmetricDifference' as addition and 'intersection' as
-- multiplication (and 'complement' as negation). In fact the algebra is Boolean
-- as the operation @x '==>' y = 'complement' x '\/' y@.
--
-- It is a monoid that is convenient for agglomerating
-- groups of intervals, such as for calculating the overall timespan
-- of a group of events. However, it is agnostic of
-- how many times each given point has been covered.
-- To keep track of this data, use 'Data.Interval.Layers.Layers'.
newtype Borel x = Borel (Set (Interval x))
  deriving (Borel x -> Borel x -> Bool
(Borel x -> Borel x -> Bool)
-> (Borel x -> Borel x -> Bool) -> Eq (Borel x)
forall x. Ord x => Borel x -> Borel x -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall x. Ord x => Borel x -> Borel x -> Bool
== :: Borel x -> Borel x -> Bool
$c/= :: forall x. Ord x => Borel x -> Borel x -> Bool
/= :: Borel x -> Borel x -> Bool
Eq, Eq (Borel x)
Eq (Borel x) =>
(Borel x -> Borel x -> Ordering)
-> (Borel x -> Borel x -> Bool)
-> (Borel x -> Borel x -> Bool)
-> (Borel x -> Borel x -> Bool)
-> (Borel x -> Borel x -> Bool)
-> (Borel x -> Borel x -> Borel x)
-> (Borel x -> Borel x -> Borel x)
-> Ord (Borel x)
Borel x -> Borel x -> Bool
Borel x -> Borel x -> Ordering
Borel x -> Borel x -> Borel x
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
forall x. Ord x => Eq (Borel x)
forall x. Ord x => Borel x -> Borel x -> Bool
forall x. Ord x => Borel x -> Borel x -> Ordering
forall x. Ord x => Borel x -> Borel x -> Borel x
$ccompare :: forall x. Ord x => Borel x -> Borel x -> Ordering
compare :: Borel x -> Borel x -> Ordering
$c< :: forall x. Ord x => Borel x -> Borel x -> Bool
< :: Borel x -> Borel x -> Bool
$c<= :: forall x. Ord x => Borel x -> Borel x -> Bool
<= :: Borel x -> Borel x -> Bool
$c> :: forall x. Ord x => Borel x -> Borel x -> Bool
> :: Borel x -> Borel x -> Bool
$c>= :: forall x. Ord x => Borel x -> Borel x -> Bool
>= :: Borel x -> Borel x -> Bool
$cmax :: forall x. Ord x => Borel x -> Borel x -> Borel x
max :: Borel x -> Borel x -> Borel x
$cmin :: forall x. Ord x => Borel x -> Borel x -> Borel x
min :: Borel x -> Borel x -> Borel x
Ord, Int -> Borel x -> ShowS
[Borel x] -> ShowS
Borel x -> String
(Int -> Borel x -> ShowS)
-> (Borel x -> String) -> ([Borel x] -> ShowS) -> Show (Borel x)
forall x. (Ord x, Show x) => Int -> Borel x -> ShowS
forall x. (Ord x, Show x) => [Borel x] -> ShowS
forall x. (Ord x, Show x) => Borel x -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall x. (Ord x, Show x) => Int -> Borel x -> ShowS
showsPrec :: Int -> Borel x -> ShowS
$cshow :: forall x. (Ord x, Show x) => Borel x -> String
show :: Borel x -> String
$cshowList :: forall x. (Ord x, Show x) => [Borel x] -> ShowS
showList :: [Borel x] -> ShowS
Show, (forall x. Borel x -> Rep (Borel x) x)
-> (forall x. Rep (Borel x) x -> Borel x) -> Generic (Borel x)
forall x. Rep (Borel x) x -> Borel x
forall x. Borel x -> Rep (Borel x) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall x x. Rep (Borel x) x -> Borel x
forall x x. Borel x -> Rep (Borel x) x
$cfrom :: forall x x. Borel x -> Rep (Borel x) x
from :: forall x. Borel x -> Rep (Borel x) x
$cto :: forall x x. Rep (Borel x) x -> Borel x
to :: forall x. Rep (Borel x) x -> Borel x
Generic, Typeable, Typeable (Borel x)
Typeable (Borel x) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Borel x -> c (Borel x))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Borel x))
-> (Borel x -> Constr)
-> (Borel x -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Borel x)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Borel x)))
-> ((forall b. Data b => b -> b) -> Borel x -> Borel x)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Borel x -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Borel x -> r)
-> (forall u. (forall d. Data d => d -> u) -> Borel x -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Borel x -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Borel x -> m (Borel x))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Borel x -> m (Borel x))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Borel x -> m (Borel x))
-> Data (Borel x)
Borel x -> Constr
Borel x -> DataType
(forall b. Data b => b -> b) -> Borel x -> Borel x
forall x. (Data x, Ord x) => Typeable (Borel x)
forall x. (Data x, Ord x) => Borel x -> Constr
forall x. (Data x, Ord x) => Borel x -> DataType
forall x.
(Data x, Ord x) =>
(forall b. Data b => b -> b) -> Borel x -> Borel x
forall x u.
(Data x, Ord x) =>
Int -> (forall d. Data d => d -> u) -> Borel x -> u
forall x u.
(Data x, Ord x) =>
(forall d. Data d => d -> u) -> Borel x -> [u]
forall x r r'.
(Data x, Ord x) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Borel x -> r
forall x r r'.
(Data x, Ord x) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Borel x -> r
forall x (m :: * -> *).
(Data x, Ord x, Monad m) =>
(forall d. Data d => d -> m d) -> Borel x -> m (Borel x)
forall x (m :: * -> *).
(Data x, Ord x, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Borel x -> m (Borel x)
forall x (c :: * -> *).
(Data x, Ord x) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Borel x)
forall x (c :: * -> *).
(Data x, Ord x) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Borel x -> c (Borel x)
forall x (t :: * -> *) (c :: * -> *).
(Data x, Ord x, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Borel x))
forall x (t :: * -> * -> *) (c :: * -> *).
(Data x, Ord x, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Borel x))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Borel x -> u
forall u. (forall d. Data d => d -> u) -> Borel x -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Borel x -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Borel x -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Borel x -> m (Borel x)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Borel x -> m (Borel x)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Borel x)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Borel x -> c (Borel x)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Borel x))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Borel x))
$cgfoldl :: forall x (c :: * -> *).
(Data x, Ord x) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Borel x -> c (Borel x)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Borel x -> c (Borel x)
$cgunfold :: forall x (c :: * -> *).
(Data x, Ord x) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Borel x)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Borel x)
$ctoConstr :: forall x. (Data x, Ord x) => Borel x -> Constr
toConstr :: Borel x -> Constr
$cdataTypeOf :: forall x. (Data x, Ord x) => Borel x -> DataType
dataTypeOf :: Borel x -> DataType
$cdataCast1 :: forall x (t :: * -> *) (c :: * -> *).
(Data x, Ord x, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Borel x))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Borel x))
$cdataCast2 :: forall x (t :: * -> * -> *) (c :: * -> *).
(Data x, Ord x, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Borel x))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Borel x))
$cgmapT :: forall x.
(Data x, Ord x) =>
(forall b. Data b => b -> b) -> Borel x -> Borel x
gmapT :: (forall b. Data b => b -> b) -> Borel x -> Borel x
$cgmapQl :: forall x r r'.
(Data x, Ord x) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Borel x -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Borel x -> r
$cgmapQr :: forall x r r'.
(Data x, Ord x) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Borel x -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Borel x -> r
$cgmapQ :: forall x u.
(Data x, Ord x) =>
(forall d. Data d => d -> u) -> Borel x -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Borel x -> [u]
$cgmapQi :: forall x u.
(Data x, Ord x) =>
Int -> (forall d. Data d => d -> u) -> Borel x -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Borel x -> u
$cgmapM :: forall x (m :: * -> *).
(Data x, Ord x, Monad m) =>
(forall d. Data d => d -> m d) -> Borel x -> m (Borel x)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Borel x -> m (Borel x)
$cgmapMp :: forall x (m :: * -> *).
(Data x, Ord x, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Borel x -> m (Borel x)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Borel x -> m (Borel x)
$cgmapMo :: forall x (m :: * -> *).
(Data x, Ord x, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Borel x -> m (Borel x)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Borel x -> m (Borel x)
Data)

instance (Ord x) => Semigroup (Borel x) where
  (<>) :: (Ord x) => Borel x -> Borel x -> Borel x
  Borel Set (Interval x)
is <> :: Ord x => Borel x -> Borel x -> Borel x
<> Borel Set (Interval x)
js = Set (Interval x) -> Borel x
forall x. Set (Interval x) -> Borel x
Borel (Set (Interval x) -> Set (Interval x)
forall x. Ord x => Set (Interval x) -> Set (Interval x)
unionsSet (Set (Interval x)
is Set (Interval x) -> Set (Interval x) -> Set (Interval x)
forall a. Semigroup a => a -> a -> a
<> Set (Interval x)
js))

instance (Ord x) => Monoid (Borel x) where
  mempty :: (Ord x) => Borel x
  mempty :: Ord x => Borel x
mempty = Set (Interval x) -> Borel x
forall x. Set (Interval x) -> Borel x
Borel Set (Interval x)
forall a. Monoid a => a
mempty

instance (Ord x) => Lattice (Borel x) where
  (\/) :: (Ord x) => Borel x -> Borel x -> Borel x
  \/ :: Ord x => Borel x -> Borel x -> Borel x
(\/) = Borel x -> Borel x -> Borel x
forall x. Ord x => Borel x -> Borel x -> Borel x
union

  (/\) :: (Ord x) => Borel x -> Borel x -> Borel x
  /\ :: Ord x => Borel x -> Borel x -> Borel x
(/\) = Borel x -> Borel x -> Borel x
forall x. Ord x => Borel x -> Borel x -> Borel x
intersection

instance (Ord x) => BoundedMeetSemiLattice (Borel x) where
  top :: (Ord x) => Borel x
  top :: Ord x => Borel x
top = Borel x
forall x. Ord x => Borel x
whole

instance (Ord x) => BoundedJoinSemiLattice (Borel x) where
  bottom :: (Ord x) => Borel x
  bottom :: Ord x => Borel x
bottom = Borel x
forall a. Monoid a => a
mempty

instance (Ord x) => Heyting (Borel x) where
  (==>) :: (Ord x) => Borel x -> Borel x -> Borel x
  Borel x
x ==> :: Ord x => Borel x -> Borel x -> Borel x
==> Borel x
y = Borel x -> Borel x
forall x. Ord x => Borel x -> Borel x
complement Borel x
x Borel x -> Borel x -> Borel x
forall a. Lattice a => a -> a -> a
\/ Borel x
y

instance (Ord x) => Semiring (Borel x) where
  plus :: (Ord x) => Borel x -> Borel x -> Borel x
  plus :: Ord x => Borel x -> Borel x -> Borel x
plus = Borel x -> Borel x -> Borel x
forall x. Ord x => Borel x -> Borel x -> Borel x
symmetricDifference

  times :: (Ord x) => Borel x -> Borel x -> Borel x
  times :: Ord x => Borel x -> Borel x -> Borel x
times = Borel x -> Borel x -> Borel x
forall x. Ord x => Borel x -> Borel x -> Borel x
intersection

  zero :: (Ord x) => Borel x
  zero :: Ord x => Borel x
zero = Borel x
forall a. Monoid a => a
mempty

  one :: (Ord x) => Borel x
  one :: Ord x => Borel x
one = Borel x
forall x. Ord x => Borel x
whole

instance (Ord x) => Ring (Borel x) where
  negate :: (Ord x) => Borel x -> Borel x
  negate :: Ord x => Borel x -> Borel x
negate = Borel x -> Borel x
forall x. Ord x => Borel x -> Borel x
complement

-- | Consider the 'Borel' set identified by a list of 'Interval's.
borel :: (Ord x) => [Interval x] -> Borel x
borel :: forall x. Ord x => [Interval x] -> Borel x
borel = Set (Interval x) -> Borel x
forall x. Set (Interval x) -> Borel x
Borel (Set (Interval x) -> Borel x)
-> ([Interval x] -> Set (Interval x)) -> [Interval x] -> Borel x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Interval x] -> Set (Interval x)
forall a. Ord a => [a] -> Set a
Set.fromList ([Interval x] -> Set (Interval x))
-> ([Interval x] -> [Interval x])
-> [Interval x]
-> Set (Interval x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Interval x] -> [Interval x]
forall x. Ord x => [Interval x] -> [Interval x]
I.unions

-- | Turn a 'Borel' set into a 'Set.Set' of 'Interval's.
intervalSet :: (Ord x) => Borel x -> Set (Interval x)
intervalSet :: forall x. Ord x => Borel x -> Set (Interval x)
intervalSet (Borel Set (Interval x)
is) = Set (Interval x) -> Set (Interval x)
forall x. Ord x => Set (Interval x) -> Set (Interval x)
unionsSet Set (Interval x)
is

unionsSet :: (Ord x) => Set (Interval x) -> Set (Interval x)
unionsSet :: forall x. Ord x => Set (Interval x) -> Set (Interval x)
unionsSet = [Interval x] -> Set (Interval x)
forall a. Eq a => [a] -> Set a
Set.fromAscList ([Interval x] -> Set (Interval x))
-> (Set (Interval x) -> [Interval x])
-> Set (Interval x)
-> Set (Interval x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Interval x] -> [Interval x]
forall x. Ord x => [Interval x] -> [Interval x]
I.unionsAsc ([Interval x] -> [Interval x])
-> (Set (Interval x) -> [Interval x])
-> Set (Interval x)
-> [Interval x]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set (Interval x) -> [Interval x]
forall a. Set a -> [a]
Set.toAscList

-- | The empty 'Borel' set.
empty :: (Ord x) => Borel x
empty :: forall x. Ord x => Borel x
empty = Set (Interval x) -> Borel x
forall x. Set (Interval x) -> Borel x
Borel Set (Interval x)
forall a. Set a
Set.empty

-- | The 'Borel' set consisting of a single 'Interval'.
singleton :: (Ord x) => Interval x -> Borel x
singleton :: forall x. Ord x => Interval x -> Borel x
singleton Interval x
x = Set (Interval x) -> Borel x
forall x. Set (Interval x) -> Borel x
Borel (Interval x -> Set (Interval x)
forall a. a -> Set a
Set.singleton Interval x
x)

-- | Is this 'Borel' set empty?
null :: Borel x -> Bool
null :: forall x. Borel x -> Bool
null (Borel Set (Interval x)
is) = Set (Interval x) -> Bool
forall a. Set a -> Bool
Set.null Set (Interval x)
is

-- | Insert an 'Interval' into a 'Borel' set, agglomerating along the way.
insert :: (Ord x) => Interval x -> Borel x -> Borel x
insert :: forall x. Ord x => Interval x -> Borel x -> Borel x
insert Interval x
i (Borel Set (Interval x)
is) = Set (Interval x) -> Borel x
forall x. Set (Interval x) -> Borel x
Borel (Set (Interval x) -> Set (Interval x)
forall x. Ord x => Set (Interval x) -> Set (Interval x)
unionsSet (Interval x -> Set (Interval x) -> Set (Interval x)
forall a. Ord a => a -> Set a -> Set a
Set.insert Interval x
i Set (Interval x)
is))

-- | The maximal 'Borel' set, that covers the entire range.
whole :: (Ord x) => Borel x
whole :: forall x. Ord x => Borel x
whole = Interval x -> Borel x
forall x. Ord x => Interval x -> Borel x
singleton Interval x
forall x. Ord x => Interval x
I.Whole

-- |
-- Completely remove an 'Interval' from a 'Borel' set.
-- Essentially the opposite of 'truncate'.
remove :: (Ord x) => Interval x -> Borel x -> Borel x
remove :: forall x. Ord x => Interval x -> Borel x -> Borel x
remove Interval x
i (Borel Set (Interval x)
is) = ((Interval x -> Borel x) -> Set (Interval x) -> Borel x)
-> Set (Interval x) -> (Interval x -> Borel x) -> Borel x
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Interval x -> Borel x) -> Set (Interval x) -> Borel x
forall m a. Monoid m => (a -> m) -> Set a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Set (Interval x)
is ((Interval x -> Borel x) -> Borel x)
-> (Interval x -> Borel x) -> Borel x
forall a b. (a -> b) -> a -> b
$ ((Maybe (OneOrTwo (Interval x)) -> Borel x)
 -> (Interval x -> Maybe (OneOrTwo (Interval x)))
 -> Interval x
 -> Borel x)
-> (Interval x -> Maybe (OneOrTwo (Interval x)))
-> (Maybe (OneOrTwo (Interval x)) -> Borel x)
-> Interval x
-> Borel x
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Maybe (OneOrTwo (Interval x)) -> Borel x)
-> (Interval x -> Maybe (OneOrTwo (Interval x)))
-> Interval x
-> Borel x
forall b c a. (b -> c) -> (a -> b) -> a -> c
(.) (Interval x -> Interval x -> Maybe (OneOrTwo (Interval x))
forall x.
Ord x =>
Interval x -> Interval x -> Maybe (OneOrTwo (Interval x))
I.\\ Interval x
i) \case
  Maybe (OneOrTwo (Interval x))
Nothing -> Borel x
forall a. Monoid a => a
mempty
  Just (One Interval x
j) -> [Interval x] -> Borel x
forall x. Ord x => [Interval x] -> Borel x
borel [Interval x
j]
  Just (Two Interval x
j Interval x
k) -> [Interval x] -> Borel x
forall x. Ord x => [Interval x] -> Borel x
borel [Interval x
j, Interval x
k]

-- | Flipped infix version of 'remove'.
(\-) :: (Ord x) => Borel x -> Interval x -> Borel x
\- :: forall x. Ord x => Borel x -> Interval x -> Borel x
(\-) = (Interval x -> Borel x -> Borel x)
-> Borel x -> Interval x -> Borel x
forall a b c. (a -> b -> c) -> b -> a -> c
flip Interval x -> Borel x -> Borel x
forall x. Ord x => Interval x -> Borel x -> Borel x
remove

-- | Is this point 'I.within' any connected component of the 'Borel' set?
member :: (Ord x) => x -> Borel x -> Bool
member :: forall x. Ord x => x -> Borel x -> Bool
member x
x (Borel Set (Interval x)
is) = (Interval x -> Bool) -> Set (Interval x) -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (Levitated x -> Interval x -> Bool
forall x. Ord x => Levitated x -> Interval x -> Bool
I.within (x -> Levitated x
forall a. a -> Levitated a
Levitate x
x)) Set (Interval x)
is

-- | Is this point not 'I.within' any connected component of the 'Borel' set?
notMember :: (Ord x) => x -> Borel x -> Bool
notMember :: forall x. Ord x => x -> Borel x -> Bool
notMember x
x = Bool -> Bool
not (Bool -> Bool) -> (Borel x -> Bool) -> Borel x -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. x -> Borel x -> Bool
forall x. Ord x => x -> Borel x -> Bool
member x
x

-- | A synonym for '(<>)'.
union :: (Ord x) => Borel x -> Borel x -> Borel x
union :: forall x. Ord x => Borel x -> Borel x -> Borel x
union = Borel x -> Borel x -> Borel x
forall a. Semigroup a => a -> a -> a
(<>)

-- | A synonym for 'fold'.
unions :: (Ord x) => [Borel x] -> Borel x
unions :: forall x. Ord x => [Borel x] -> Borel x
unions = [Borel x] -> Borel x
forall m. Monoid m => [m] -> m
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold

-- | Remove all intervals of the second set from the first.
difference :: (Ord x) => Borel x -> Borel x -> Borel x
difference :: forall x. Ord x => Borel x -> Borel x -> Borel x
difference Borel x
is (Borel Set (Interval x)
js) = (Interval x -> Borel x -> Borel x)
-> Borel x -> Set (Interval x) -> Borel x
forall a b. (a -> b -> b) -> b -> Set a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Interval x -> Borel x -> Borel x
forall x. Ord x => Interval x -> Borel x -> Borel x
remove Borel x
is Set (Interval x)
js

-- | Take the symmetric difference of two 'Borel' sets.
symmetricDifference :: (Ord x) => Borel x -> Borel x -> Borel x
symmetricDifference :: forall x. Ord x => Borel x -> Borel x -> Borel x
symmetricDifference Borel x
is Borel x
js = Borel x -> Borel x -> Borel x
forall x. Ord x => Borel x -> Borel x -> Borel x
difference Borel x
is Borel x
js Borel x -> Borel x -> Borel x
forall a. Semigroup a => a -> a -> a
<> Borel x -> Borel x -> Borel x
forall x. Ord x => Borel x -> Borel x -> Borel x
difference Borel x
js Borel x
is

-- | Take the 'Borel' set consisting of each point not in the given one.
complement :: (Ord x) => Borel x -> Borel x
complement :: forall x. Ord x => Borel x -> Borel x
complement = Borel x -> Borel x -> Borel x
forall x. Ord x => Borel x -> Borel x -> Borel x
difference Borel x
forall x. Ord x => Borel x
whole

-- | Given an 'Interval' @i@, @'truncate' i@ will trim a 'Borel' set
-- so that its 'hull' is contained in @i@.
truncate :: (Ord x) => Interval x -> Borel x -> Borel x
truncate :: forall x. Ord x => Interval x -> Borel x -> Borel x
truncate Interval x
i (Borel Set (Interval x)
js) =
  (Interval x -> Borel x -> Borel x)
-> Borel x -> Set (Interval x) -> Borel x
forall a b. (a -> b -> b) -> b -> Set a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (Borel x -> Borel x -> Borel x
forall a. Semigroup a => a -> a -> a
(<>) (Borel x -> Borel x -> Borel x)
-> (Interval x -> Borel x) -> Interval x -> Borel x -> Borel x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Borel x -> (Interval x -> Borel x) -> Maybe (Interval x) -> Borel x
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Borel x
forall a. Monoid a => a
mempty Interval x -> Borel x
forall x. Ord x => Interval x -> Borel x
singleton (Maybe (Interval x) -> Borel x)
-> (Interval x -> Maybe (Interval x)) -> Interval x -> Borel x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Interval x -> Interval x -> Maybe (Interval x)
forall x. Ord x => Interval x -> Interval x -> Maybe (Interval x)
I.intersect Interval x
i) Borel x
forall a. Monoid a => a
mempty Set (Interval x)
js

-- | Flipped infix version of 'truncate'.
(\=) :: (Ord x) => Borel x -> Interval x -> Borel x
\= :: forall x. Ord x => Borel x -> Interval x -> Borel x
(\=) = (Interval x -> Borel x -> Borel x)
-> Borel x -> Interval x -> Borel x
forall a b c. (a -> b -> c) -> b -> a -> c
flip Interval x -> Borel x -> Borel x
forall x. Ord x => Interval x -> Borel x -> Borel x
truncate

-- | Take the intersection of two 'Borel' sets.
intersection :: (Ord x) => Borel x -> Borel x -> Borel x
intersection :: forall x. Ord x => Borel x -> Borel x -> Borel x
intersection Borel x
is (Borel Set (Interval x)
js) = (Interval x -> Borel x) -> Set (Interval x) -> Borel x
forall m a. Monoid m => (a -> m) -> Set a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (Interval x -> Borel x -> Borel x
forall x. Ord x => Interval x -> Borel x -> Borel x
`truncate` Borel x
is) Set (Interval x)
js

-- | Take the intersection of a list of 'Borel' sets.
intersections :: (Ord x) => [Borel x] -> Borel x
intersections :: forall x. Ord x => [Borel x] -> Borel x
intersections = Shrink x -> Borel x
forall x. Shrink x -> Borel x
getShrink (Shrink x -> Borel x)
-> ([Borel x] -> Shrink x) -> [Borel x] -> Borel x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Borel x -> Shrink x) -> [Borel x] -> Shrink x
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Borel x -> Shrink x
forall x. Borel x -> Shrink x
Shrink

-- | Take the smallest spanning 'Interval' of a 'Borel' set,
-- provided that it is not the empty set.
hull :: (Ord x) => Borel x -> Maybe (Interval x)
hull :: forall x. Ord x => Borel x -> Maybe (Interval x)
hull (Borel Set (Interval x)
js) = Set (Interval x) -> Maybe (Interval x, Set (Interval x))
forall a. Set a -> Maybe (a, Set a)
Set.minView Set (Interval x)
js Maybe (Interval x, Set (Interval x))
-> ((Interval x, Set (Interval x)) -> Interval x)
-> Maybe (Interval x)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(Interval x
i, Set (Interval x)
is) -> NonEmpty (Interval x) -> Interval x
forall x. Ord x => NonEmpty (Interval x) -> Interval x
I.hulls (Interval x
i Interval x -> [Interval x] -> NonEmpty (Interval x)
forall a. a -> [a] -> NonEmpty a
:| Set (Interval x) -> [Interval x]
forall a. Set a -> [a]
Set.toAscList Set (Interval x)
is)

isSubsetOf :: (Ord x) => Borel x -> Borel x -> Bool
isSubsetOf :: forall x. Ord x => Borel x -> Borel x -> Bool
isSubsetOf Borel x
is Borel x
js = Borel x -> Bool
forall x. Borel x -> Bool
null (Borel x -> Bool) -> Borel x -> Bool
forall a b. (a -> b) -> a -> b
$ Borel x -> Borel x -> Borel x
forall x. Ord x => Borel x -> Borel x -> Borel x
difference Borel x
is Borel x
js

-- | Newtype wrapper for the monoid under 'intersection'.
newtype Shrink x = Shrink {forall x. Shrink x -> Borel x
getShrink :: Borel x}
  deriving (Shrink x -> Shrink x -> Bool
(Shrink x -> Shrink x -> Bool)
-> (Shrink x -> Shrink x -> Bool) -> Eq (Shrink x)
forall x. Ord x => Shrink x -> Shrink x -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall x. Ord x => Shrink x -> Shrink x -> Bool
== :: Shrink x -> Shrink x -> Bool
$c/= :: forall x. Ord x => Shrink x -> Shrink x -> Bool
/= :: Shrink x -> Shrink x -> Bool
Eq, Eq (Shrink x)
Eq (Shrink x) =>
(Shrink x -> Shrink x -> Ordering)
-> (Shrink x -> Shrink x -> Bool)
-> (Shrink x -> Shrink x -> Bool)
-> (Shrink x -> Shrink x -> Bool)
-> (Shrink x -> Shrink x -> Bool)
-> (Shrink x -> Shrink x -> Shrink x)
-> (Shrink x -> Shrink x -> Shrink x)
-> Ord (Shrink x)
Shrink x -> Shrink x -> Bool
Shrink x -> Shrink x -> Ordering
Shrink x -> Shrink x -> Shrink x
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
forall x. Ord x => Eq (Shrink x)
forall x. Ord x => Shrink x -> Shrink x -> Bool
forall x. Ord x => Shrink x -> Shrink x -> Ordering
forall x. Ord x => Shrink x -> Shrink x -> Shrink x
$ccompare :: forall x. Ord x => Shrink x -> Shrink x -> Ordering
compare :: Shrink x -> Shrink x -> Ordering
$c< :: forall x. Ord x => Shrink x -> Shrink x -> Bool
< :: Shrink x -> Shrink x -> Bool
$c<= :: forall x. Ord x => Shrink x -> Shrink x -> Bool
<= :: Shrink x -> Shrink x -> Bool
$c> :: forall x. Ord x => Shrink x -> Shrink x -> Bool
> :: Shrink x -> Shrink x -> Bool
$c>= :: forall x. Ord x => Shrink x -> Shrink x -> Bool
>= :: Shrink x -> Shrink x -> Bool
$cmax :: forall x. Ord x => Shrink x -> Shrink x -> Shrink x
max :: Shrink x -> Shrink x -> Shrink x
$cmin :: forall x. Ord x => Shrink x -> Shrink x -> Shrink x
min :: Shrink x -> Shrink x -> Shrink x
Ord, Int -> Shrink x -> ShowS
[Shrink x] -> ShowS
Shrink x -> String
(Int -> Shrink x -> ShowS)
-> (Shrink x -> String) -> ([Shrink x] -> ShowS) -> Show (Shrink x)
forall x. (Ord x, Show x) => Int -> Shrink x -> ShowS
forall x. (Ord x, Show x) => [Shrink x] -> ShowS
forall x. (Ord x, Show x) => Shrink x -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall x. (Ord x, Show x) => Int -> Shrink x -> ShowS
showsPrec :: Int -> Shrink x -> ShowS
$cshow :: forall x. (Ord x, Show x) => Shrink x -> String
show :: Shrink x -> String
$cshowList :: forall x. (Ord x, Show x) => [Shrink x] -> ShowS
showList :: [Shrink x] -> ShowS
Show, (forall x. Shrink x -> Rep (Shrink x) x)
-> (forall x. Rep (Shrink x) x -> Shrink x) -> Generic (Shrink x)
forall x. Rep (Shrink x) x -> Shrink x
forall x. Shrink x -> Rep (Shrink x) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall x x. Rep (Shrink x) x -> Shrink x
forall x x. Shrink x -> Rep (Shrink x) x
$cfrom :: forall x x. Shrink x -> Rep (Shrink x) x
from :: forall x. Shrink x -> Rep (Shrink x) x
$cto :: forall x x. Rep (Shrink x) x -> Shrink x
to :: forall x. Rep (Shrink x) x -> Shrink x
Generic, Typeable, Typeable (Shrink x)
Typeable (Shrink x) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Shrink x -> c (Shrink x))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Shrink x))
-> (Shrink x -> Constr)
-> (Shrink x -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Shrink x)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Shrink x)))
-> ((forall b. Data b => b -> b) -> Shrink x -> Shrink x)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Shrink x -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Shrink x -> r)
-> (forall u. (forall d. Data d => d -> u) -> Shrink x -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Shrink x -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Shrink x -> m (Shrink x))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Shrink x -> m (Shrink x))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Shrink x -> m (Shrink x))
-> Data (Shrink x)
Shrink x -> Constr
Shrink x -> DataType
(forall b. Data b => b -> b) -> Shrink x -> Shrink x
forall x. (Data x, Ord x) => Typeable (Shrink x)
forall x. (Data x, Ord x) => Shrink x -> Constr
forall x. (Data x, Ord x) => Shrink x -> DataType
forall x.
(Data x, Ord x) =>
(forall b. Data b => b -> b) -> Shrink x -> Shrink x
forall x u.
(Data x, Ord x) =>
Int -> (forall d. Data d => d -> u) -> Shrink x -> u
forall x u.
(Data x, Ord x) =>
(forall d. Data d => d -> u) -> Shrink x -> [u]
forall x r r'.
(Data x, Ord x) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Shrink x -> r
forall x r r'.
(Data x, Ord x) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Shrink x -> r
forall x (m :: * -> *).
(Data x, Ord x, Monad m) =>
(forall d. Data d => d -> m d) -> Shrink x -> m (Shrink x)
forall x (m :: * -> *).
(Data x, Ord x, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Shrink x -> m (Shrink x)
forall x (c :: * -> *).
(Data x, Ord x) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Shrink x)
forall x (c :: * -> *).
(Data x, Ord x) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Shrink x -> c (Shrink x)
forall x (t :: * -> *) (c :: * -> *).
(Data x, Ord x, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Shrink x))
forall x (t :: * -> * -> *) (c :: * -> *).
(Data x, Ord x, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Shrink x))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Shrink x -> u
forall u. (forall d. Data d => d -> u) -> Shrink x -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Shrink x -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Shrink x -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Shrink x -> m (Shrink x)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Shrink x -> m (Shrink x)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Shrink x)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Shrink x -> c (Shrink x)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Shrink x))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Shrink x))
$cgfoldl :: forall x (c :: * -> *).
(Data x, Ord x) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Shrink x -> c (Shrink x)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Shrink x -> c (Shrink x)
$cgunfold :: forall x (c :: * -> *).
(Data x, Ord x) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Shrink x)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Shrink x)
$ctoConstr :: forall x. (Data x, Ord x) => Shrink x -> Constr
toConstr :: Shrink x -> Constr
$cdataTypeOf :: forall x. (Data x, Ord x) => Shrink x -> DataType
dataTypeOf :: Shrink x -> DataType
$cdataCast1 :: forall x (t :: * -> *) (c :: * -> *).
(Data x, Ord x, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Shrink x))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Shrink x))
$cdataCast2 :: forall x (t :: * -> * -> *) (c :: * -> *).
(Data x, Ord x, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Shrink x))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Shrink x))
$cgmapT :: forall x.
(Data x, Ord x) =>
(forall b. Data b => b -> b) -> Shrink x -> Shrink x
gmapT :: (forall b. Data b => b -> b) -> Shrink x -> Shrink x
$cgmapQl :: forall x r r'.
(Data x, Ord x) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Shrink x -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Shrink x -> r
$cgmapQr :: forall x r r'.
(Data x, Ord x) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Shrink x -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Shrink x -> r
$cgmapQ :: forall x u.
(Data x, Ord x) =>
(forall d. Data d => d -> u) -> Shrink x -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Shrink x -> [u]
$cgmapQi :: forall x u.
(Data x, Ord x) =>
Int -> (forall d. Data d => d -> u) -> Shrink x -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Shrink x -> u
$cgmapM :: forall x (m :: * -> *).
(Data x, Ord x, Monad m) =>
(forall d. Data d => d -> m d) -> Shrink x -> m (Shrink x)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Shrink x -> m (Shrink x)
$cgmapMp :: forall x (m :: * -> *).
(Data x, Ord x, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Shrink x -> m (Shrink x)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Shrink x -> m (Shrink x)
$cgmapMo :: forall x (m :: * -> *).
(Data x, Ord x, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Shrink x -> m (Shrink x)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Shrink x -> m (Shrink x)
Data)

instance (Ord x) => Semigroup (Shrink x) where
  (<>) :: (Ord x) => Shrink x -> Shrink x -> Shrink x
  Shrink Borel x
x <> :: Ord x => Shrink x -> Shrink x -> Shrink x
<> Shrink Borel x
y = Borel x -> Shrink x
forall x. Borel x -> Shrink x
Shrink (Borel x -> Borel x -> Borel x
forall x. Ord x => Borel x -> Borel x -> Borel x
intersection Borel x
x Borel x
y)

instance (Ord x) => Monoid (Shrink x) where
  mempty :: (Ord x) => Shrink x
  mempty :: Ord x => Shrink x
mempty = Borel x -> Shrink x
forall x. Borel x -> Shrink x
Shrink Borel x
forall x. Ord x => Borel x
whole