Data.Interval

Intervals over types and their operations.

Documentation

data Extremum

The kinds of extremum an interval can have.

Constructors

Minimum

Infimum

Supremum

Maximum

Instances

Data Extremum

Defined in Data.Interval

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Extremum -> c Extremum

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Extremum

toConstr :: Extremum -> Constr

dataTypeOf :: Extremum -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Extremum)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Extremum)

gmapT :: (forall b. Data b => b -> b) -> Extremum -> Extremum

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Extremum -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Extremum -> r

gmapQ :: (forall d. Data d => d -> u) -> Extremum -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Extremum -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Extremum -> m Extremum

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Extremum -> m Extremum

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Extremum -> m Extremum

Bounded Extremum

Defined in Data.Interval

Methods

minBound :: Extremum

maxBound :: Extremum

Enum Extremum

Defined in Data.Interval

Methods

succ :: Extremum -> Extremum

pred :: Extremum -> Extremum

toEnum :: Int -> Extremum

fromEnum :: Extremum -> Int

enumFrom :: Extremum -> [Extremum]

enumFromThen :: Extremum -> Extremum -> [Extremum]

enumFromTo :: Extremum -> Extremum -> [Extremum]

enumFromThenTo :: Extremum -> Extremum -> Extremum -> [Extremum]

Generic Extremum

Defined in Data.Interval

Associated Types

type Rep Extremum :: Type -> Type

Methods

from :: Extremum -> Rep Extremum x

to :: Rep Extremum x -> Extremum

Read Extremum

Defined in Data.Interval

Methods

readsPrec :: Int -> ReadS Extremum

readList :: ReadS [Extremum]

readPrec :: ReadPrec Extremum

readListPrec :: ReadPrec [Extremum]

Show Extremum

Defined in Data.Interval

Methods

showsPrec :: Int -> Extremum -> ShowS

show :: Extremum -> String

showList :: [Extremum] -> ShowS

Eq Extremum

Defined in Data.Interval

Methods

(==) :: Extremum -> Extremum -> Bool

(/=) :: Extremum -> Extremum -> Bool

Ord Extremum

Defined in Data.Interval

Methods

compare :: Extremum -> Extremum -> Ordering

(<) :: Extremum -> Extremum -> Bool

(<=) :: Extremum -> Extremum -> Bool

(>) :: Extremum -> Extremum -> Bool

(>=) :: Extremum -> Extremum -> Bool

max :: Extremum -> Extremum -> Extremum

min :: Extremum -> Extremum -> Extremum

type Rep Extremum

Defined in Data.Interval

type Rep Extremum = D1 ('MetaData "Extremum" "Data.Interval" "interval-patterns-0.6.0.1-AWVGvVImLF665RHNyYdFZ" 'False) ((C1 ('MetaCons "Minimum" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Infimum" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Supremum" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Maximum" 'PrefixI 'False) (U1 :: Type -> Type)))

opposite :: Extremum -> Extremum

The opposite of an Extremum is its complementary analogue: how the same point would be viewed from the complement of the interval to which it belongs.

c.f. opposeBound.

data Bound ext x where

A Bound is an endpoint of an Interval.

Constructors

Min :: !x -> Bound Minimum x

Inf :: !x -> Bound Infimum x

Sup :: !x -> Bound Supremum x

Max :: !x -> Bound Maximum x

Instances

Foldable (Bound ext)

Defined in Data.Interval

Methods

fold :: Monoid m => Bound ext m -> m

foldMap :: Monoid m => (a -> m) -> Bound ext a -> m

foldMap' :: Monoid m => (a -> m) -> Bound ext a -> m

foldr :: (a -> b -> b) -> b -> Bound ext a -> b

foldr' :: (a -> b -> b) -> b -> Bound ext a -> b

foldl :: (b -> a -> b) -> b -> Bound ext a -> b

foldl' :: (b -> a -> b) -> b -> Bound ext a -> b

foldr1 :: (a -> a -> a) -> Bound ext a -> a

foldl1 :: (a -> a -> a) -> Bound ext a -> a

toList :: Bound ext a -> [a]

null :: Bound ext a -> Bool

length :: Bound ext a -> Int

elem :: Eq a => a -> Bound ext a -> Bool

maximum :: Ord a => Bound ext a -> a

minimum :: Ord a => Bound ext a -> a

sum :: Num a => Bound ext a -> a

product :: Num a => Bound ext a -> a

Traversable (Bound ext)

Defined in Data.Interval

Methods

traverse :: Applicative f => (a -> f b) -> Bound ext a -> f (Bound ext b)

sequenceA :: Applicative f => Bound ext (f a) -> f (Bound ext a)

mapM :: Monad m => (a -> m b) -> Bound ext a -> m (Bound ext b)

sequence :: Monad m => Bound ext (m a) -> m (Bound ext a)

Functor (Bound ext)

Defined in Data.Interval

Methods

fmap :: (a -> b) -> Bound ext a -> Bound ext b

(<$) :: a -> Bound ext b -> Bound ext a

Eq x => Eq (Bound ext x)

Defined in Data.Interval

Methods

(==) :: Bound ext x -> Bound ext x -> Bool

(/=) :: Bound ext x -> Bound ext x -> Bool

Ord x => Ord (Bound ext (Levitated x))

Defined in Data.Interval

Methods

compare :: Bound ext (Levitated x) -> Bound ext (Levitated x) -> Ordering

(<) :: Bound ext (Levitated x) -> Bound ext (Levitated x) -> Bool

(<=) :: Bound ext (Levitated x) -> Bound ext (Levitated x) -> Bool

(>) :: Bound ext (Levitated x) -> Bound ext (Levitated x) -> Bool

(>=) :: Bound ext (Levitated x) -> Bound ext (Levitated x) -> Bool

max :: Bound ext (Levitated x) -> Bound ext (Levitated x) -> Bound ext (Levitated x)

min :: Bound ext (Levitated x) -> Bound ext (Levitated x) -> Bound ext (Levitated x)

unBound :: Bound ext x -> x

Extract the term from a Bound.

class Opposite (Opposite ext) ~ ext => Bounding ext where

A type class for inverting Bounds.

Associated Types

type Opposite ext :: Extremum

Methods

bound :: x -> Bound ext x

opposeBound :: Bound ext x -> Bound (Opposite ext) x

c.f. opposite.

Instances

Bounding 'Infimum

Defined in Data.Interval

Associated Types

type Opposite 'Infimum :: Extremum

Methods

bound :: x -> Bound 'Infimum x

opposeBound :: Bound 'Infimum x -> Bound (Opposite 'Infimum) x

Bounding 'Maximum

Defined in Data.Interval

Associated Types

type Opposite 'Maximum :: Extremum

Methods

bound :: x -> Bound 'Maximum x

opposeBound :: Bound 'Maximum x -> Bound (Opposite 'Maximum) x

Bounding 'Minimum

Defined in Data.Interval

Associated Types

type Opposite 'Minimum :: Extremum

Methods

bound :: x -> Bound 'Minimum x

opposeBound :: Bound 'Minimum x -> Bound (Opposite 'Minimum) x

Bounding 'Supremum

Defined in Data.Interval

Associated Types

type Opposite 'Supremum :: Extremum

Methods

bound :: x -> Bound 'Supremum x

opposeBound :: Bound 'Supremum x -> Bound (Opposite 'Supremum) x

compareBounds :: Ord x => Bound ext1 x -> Bound ext2 x -> Ordering

Bounds have special comparison rules for identical points.

>>> compareBounds (Min (Levitate 5)) (Max (Levitate 5))
EQ
>>> compareBounds (Inf (Levitate 5)) (Sup (Levitate 5))
GT
>>> compareBounds (Max (Levitate 5)) (Sup (Levitate 5))
GT
>>> compareBounds (Inf (Levitate 5)) (Min (Levitate 5))
GT
>>> compareBounds (Max (Levitate 5)) (Inf (Levitate 5))
LT

data SomeBound x

Constructors

forall ext.(Bounding ext, Bounding (Opposite ext)) => SomeBound !(Bound ext x)

Instances

Eq x => Eq (SomeBound (Levitated x))

Defined in Data.Interval

Methods

(==) :: SomeBound (Levitated x) -> SomeBound (Levitated x) -> Bool

(/=) :: SomeBound (Levitated x) -> SomeBound (Levitated x) -> Bool

Ord x => Ord (SomeBound (Levitated x))

Defined in Data.Interval

Methods

compare :: SomeBound (Levitated x) -> SomeBound (Levitated x) -> Ordering

(<) :: SomeBound (Levitated x) -> SomeBound (Levitated x) -> Bool

(<=) :: SomeBound (Levitated x) -> SomeBound (Levitated x) -> Bool

(>) :: SomeBound (Levitated x) -> SomeBound (Levitated x) -> Bool

(>=) :: SomeBound (Levitated x) -> SomeBound (Levitated x) -> Bool

max :: SomeBound (Levitated x) -> SomeBound (Levitated x) -> SomeBound (Levitated x)

min :: SomeBound (Levitated x) -> SomeBound (Levitated x) -> SomeBound (Levitated x)

unSomeBound :: Ord x => SomeBound x -> x

oppose :: SomeBound x -> SomeBound x

data Interval x where

Constructors

(:<-->:) :: Ord x => !(Bound Infimum (Levitated x)) -> !(Bound Supremum (Levitated x)) -> Interval x infix 5

(:<--|:) :: Ord x => !(Bound Infimum (Levitated x)) -> !(Bound Maximum (Levitated x)) -> Interval x infix 5

(:|-->:) :: Ord x => !(Bound Minimum (Levitated x)) -> !(Bound Supremum (Levitated x)) -> Interval x infix 5

(:|--|:) :: Ord x => !(Bound Minimum (Levitated x)) -> !(Bound Maximum (Levitated x)) -> Interval x infix 5

Instances

(Ord x, Data x) => Data (Interval x)

Defined in Data.Interval

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Interval x -> c (Interval x)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Interval x)

toConstr :: Interval x -> Constr

dataTypeOf :: Interval x -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Interval x))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Interval x))

gmapT :: (forall b. Data b => b -> b) -> Interval x -> Interval x

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Interval x -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Interval x -> r

gmapQ :: (forall d. Data d => d -> u) -> Interval x -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Interval x -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Interval x -> m (Interval x)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Interval x -> m (Interval x)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Interval x -> m (Interval x)

(Ord x, Generic x) => Generic (Interval x)

Defined in Data.Interval

Associated Types

type Rep (Interval x) :: Type -> Type

Methods

from :: Interval x -> Rep (Interval x) x0

to :: Rep (Interval x) x0 -> Interval x

(Ord x, Show x) => Show (Interval x)

Defined in Data.Interval

Methods

showsPrec :: Int -> Interval x -> ShowS

show :: Interval x -> String

showList :: [Interval x] -> ShowS

Ord x => Eq (Interval x)

Defined in Data.Interval

Methods

(==) :: Interval x -> Interval x -> Bool

(/=) :: Interval x -> Interval x -> Bool

Ord x => Ord (Interval x)

Defined in Data.Interval

Methods

compare :: Interval x -> Interval x -> Ordering

(<) :: Interval x -> Interval x -> Bool

(<=) :: Interval x -> Interval x -> Bool

(>) :: Interval x -> Interval x -> Bool

(>=) :: Interval x -> Interval x -> Bool

max :: Interval x -> Interval x -> Interval x

min :: Interval x -> Interval x -> Interval x

type Rep (Interval x)

Defined in Data.Interval

type Rep (Interval x) = (Const (Levitated x, Extremum) :: Type -> Type) :*: (Const (Levitated x, Extremum) :: Type -> Type)

imap :: (Ord x, Ord y) => (x -> y) -> Interval x -> Interval y

Since the Ord constraints on the constructors for Interval prevent it from being a Functor, this will have to suffice.

imapLev :: (Ord x, Ord y) => (Levitated x -> Levitated y) -> Interval x -> Interval y

Same as imap but on the Levitated of the underlying type.

itraverse :: (Ord x, Ord y, Applicative f) => (x -> f y) -> Interval x -> f (Interval y)

Since the Ord constraints on the constructors for Interval prevent it from being Traversable, this will have to suffice.

itraverseLev :: (Ord x, Ord y, Applicative f) => (Levitated x -> f (Levitated y)) -> Interval x -> f (Interval y)

Same as itraverse but on the Levitated of the underlying type.

pattern (:<->:) :: Ord x => Levitated x -> Levitated x -> Interval x infix 5

A bidirectional pattern synonym matching open intervals.

pattern (:<-|:) :: Ord x => Levitated x -> Levitated x -> Interval x infix 5

A bidirectional pattern synonym matching open-closed intervals.

pattern (:|->:) :: Ord x => Levitated x -> Levitated x -> Interval x infix 5

A bidirectional pattern synonym matching closed-open intervals.

pattern (:|-|:) :: Ord x => Levitated x -> Levitated x -> Interval x infix 5

A bidirectional pattern synonym matching closed intervals.

pattern (:---:) :: forall x. Ord x => Levitated x -> Levitated x -> Interval x

A unidirectional pattern synonym ignoring the particular Bounds.

pattern (:<>:) :: forall x. Ord x => x -> x -> Interval x infix 5

A bidirectional pattern synonym matching finite open intervals.

pattern (:<|:) :: forall x. Ord x => x -> x -> Interval x infix 5

A bidirectional pattern synonym matching finite open-closed intervals.

pattern (:|>:) :: forall x. Ord x => x -> x -> Interval x infix 5

A bidirectional pattern synonym matching finite closed-open intervals.

pattern (:||:) :: forall x. Ord x => x -> x -> Interval x infix 5

A bidirectional pattern synonym matching finite closed intervals.

pattern (:--:) :: forall x. Ord x => x -> x -> Interval x

A unidirectional pattern synonym matching finite intervals, that ignores the particular Bounds.

pattern Whole :: Ord x => Interval x

The whole interval.

(+/-) :: (Ord x, Num x) => x -> x -> Interval x

m +/- r creates the closed interval centred at m with radius r.

For the open interval, simply write open (x +/- y).

(...) :: Ord x => (Levitated x, Extremum) -> (Levitated x, Extremum) -> Interval x

Given limits and Extremums, try to make an interval.

bounds :: Interval x -> (SomeBound (Levitated x), SomeBound (Levitated x))

Get the (lower, upper) bounds of an Interval.

c.f. lower, upper.

lower :: Ord x => Interval x -> SomeBound (Levitated x)

Get the lower bound of an interval.

lower = fst . bounds

lowerBound :: Ord x => Interval x -> (Levitated x, Extremum)

Get the lower bound of an interval (with the bound expressed at the term level).

upper :: Ord x => Interval x -> SomeBound (Levitated x)

Get the upper bound of an interval.

upper = snd . bounds

upperBound :: Ord x => Interval x -> (Levitated x, Extremum)

Get the upper bound of an interval (with the bound expressed at the term level).

interval :: Ord x => SomeBound (Levitated x) -> SomeBound (Levitated x) -> Interval x

Given SomeBounds, try to make an interval.

imin :: Ord x => Interval x -> Maybe (Levitated x)

Get the minimum of an interval, if it exists.

iinf :: Ord x => Interval x -> Levitated x

Get the infimum of an interval, weakening if necessary.

isup :: Ord x => Interval x -> Levitated x

Get the supremum of an interval, weakening if necessary.

imax :: Ord x => Interval x -> Maybe (Levitated x)

Get the maximum of an interval if it exists.

hull :: Ord x => Interval x -> Interval x -> Interval x

Get the convex hull of two intervals.

>>> hull (7 :|>: 8) (3 :|>: 4)
(3 :|>: 8)

>>> hull (Bottom :<-|: Levitate 3) (4 :<>: 5)
(Bottom :<->: Levitate 5)

hulls :: Ord x => NonEmpty (Interval x) -> Interval x

Get the convex hull of a non-empty list of intervals.

within :: Ord x => x -> Interval x -> Bool

Test whether a point is contained in the interval.

point :: Ord x => x -> Interval x

Create the closed-closed interval at a given point.

open :: Ord x => Interval x -> Interval x

Open both bounds of the given interval.

close :: Ord x => Interval x -> Interval x

Close both bounds of the given interval.

openclosed :: Ord x => Interval x -> Interval x

Make the interval open-closed, leaving the endpoints unchanged.

closedopen :: Ord x => Interval x -> Interval x

Make the interval closed-open, leaving the endpoints unchanged.

openLower :: Ord x => Interval x -> Interval x

Make the lower bound open, leaving the endpoints unchanged.

closedLower :: Ord x => Interval x -> Interval x

Make the lower bound closed, leaving the endpoints unchanged.

openUpper :: Ord x => Interval x -> Interval x

Make the upper bound open, leaving the endpoints unchanged.

closedUpper :: Ord x => Interval x -> Interval x

Make the upper bound closed, leaving the endpoints unchanged.

setLower :: Ord x => Levitated x -> Interval x -> Interval x

setUpper :: Ord x => Levitated x -> Interval x -> Interval x

data Adjacency x

According to Allen, two intervals can be "adjacent" in 13 different ways, into at most 3 distinct intervals. In this package, this quality is called the Adjacency of the intervals.

Constructors

Before !(Interval x) !(Interval x)

Meets !(Interval x) !(Interval x) !(Interval x)

Overlaps !(Interval x) !(Interval x) !(Interval x)

Starts !(Interval x) !(Interval x)

During !(Interval x) !(Interval x) !(Interval x)

Finishes !(Interval x) !(Interval x)

Identical !(Interval x)

FinishedBy !(Interval x) !(Interval x)

Contains !(Interval x) !(Interval x) !(Interval x)

StartedBy !(Interval x) !(Interval x)

OverlappedBy !(Interval x) !(Interval x) !(Interval x)

MetBy !(Interval x) !(Interval x) !(Interval x)

After !(Interval x) !(Interval x)

Instances

(Data x, Ord x) => Data (Adjacency x)

Defined in Data.Interval

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Adjacency x -> c (Adjacency x)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Adjacency x)

toConstr :: Adjacency x -> Constr

dataTypeOf :: Adjacency x -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Adjacency x))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Adjacency x))

gmapT :: (forall b. Data b => b -> b) -> Adjacency x -> Adjacency x

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Adjacency x -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Adjacency x -> r

gmapQ :: (forall d. Data d => d -> u) -> Adjacency x -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Adjacency x -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Adjacency x -> m (Adjacency x)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Adjacency x -> m (Adjacency x)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Adjacency x -> m (Adjacency x)

Generic (Adjacency x)

Defined in Data.Interval

Associated Types

type Rep (Adjacency x) :: Type -> Type

Methods

from :: Adjacency x -> Rep (Adjacency x) x0

to :: Rep (Adjacency x) x0 -> Adjacency x

(Ord x, Show x) => Show (Adjacency x)

Defined in Data.Interval

Methods

showsPrec :: Int -> Adjacency x -> ShowS

show :: Adjacency x -> String

showList :: [Adjacency x] -> ShowS

Ord x => Eq (Adjacency x)

Defined in Data.Interval

Methods

(==) :: Adjacency x -> Adjacency x -> Bool

(/=) :: Adjacency x -> Adjacency x -> Bool

Ord x => Ord (Adjacency x)

Defined in Data.Interval

Methods

compare :: Adjacency x -> Adjacency x -> Ordering

(<) :: Adjacency x -> Adjacency x -> Bool

(<=) :: Adjacency x -> Adjacency x -> Bool

(>) :: Adjacency x -> Adjacency x -> Bool

(>=) :: Adjacency x -> Adjacency x -> Bool

max :: Adjacency x -> Adjacency x -> Adjacency x

min :: Adjacency x -> Adjacency x -> Adjacency x

type Rep (Adjacency x)

Defined in Data.Interval

type Rep (Adjacency x) = D1 ('MetaData "Adjacency" "Data.Interval" "interval-patterns-0.6.0.1-AWVGvVImLF665RHNyYdFZ" 'False) (((C1 ('MetaCons "Before" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x))) :+: (C1 ('MetaCons "Meets" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)))) :+: C1 ('MetaCons "Overlaps" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)))))) :+: (C1 ('MetaCons "Starts" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x))) :+: (C1 ('MetaCons "During" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)))) :+: C1 ('MetaCons "Finishes" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)))))) :+: ((C1 ('MetaCons "Identical" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x))) :+: (C1 ('MetaCons "FinishedBy" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x))) :+: C1 ('MetaCons "Contains" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)))))) :+: ((C1 ('MetaCons "StartedBy" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x))) :+: C1 ('MetaCons "OverlappedBy" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x))))) :+: (C1 ('MetaCons "MetBy" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)))) :+: C1 ('MetaCons "After" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Interval x)))))))

converseAdjacency :: Adjacency x -> Adjacency x

The result of having compared the same two intervals in reverse order.

adjacency :: Ord x => Interval x -> Interval x -> Adjacency x

Calculate the Adjacency between two intervals, according to Allen.

intersect :: forall x. Ord x => Interval x -> Interval x -> Maybe (Interval x)

Calculate the intersection of two intervals, if it exists.

>>> intersect (2 :<>: 4) (3 :||: 5)
Just (3 :|>: 4)

>>> intersect (2 :<>: 4) (4 :||: 5)
Nothing

>>> intersect (1 :<>: 4) (2 :||: 3)
Just (2 :||: 3)

union :: forall x. Ord x => Interval x -> Interval x -> OneOrTwo (Interval x)

Get the union of two intervals, as either OneOrTwo.

>>> union (2 :||: 5) (5 :<>: 7)
One (Levitate 2 :|->: Levitate 7)

>>> union (2 :||: 4) (5 :<>: 7)
Two (Levitate 2 :|-|: Levitate 4) (Levitate 5 :-: Levitate 7)

unions :: forall x. Ord x => [Interval x] -> [Interval x]

O(n log n). Get the union of a list of intervals.

This function uses sort. See also unionsAsc.

unionsAsc :: forall x. Ord x => [Interval x] -> [Interval x]

O(n). Get the union of a sorted list of intervals.

NOTE: The input condition is not checked. Use with care.

complement :: forall x. Ord x => Interval x -> Maybe (OneOrTwo (Interval x))

Take the complement of the interval, as possibly OneOrTwo.

>>> complement (3 :<>: 4)
Just (Two (Bottom :|-|: Levitate 3) (Levitate 4 :|-|: Top))

Note that infinitely-open intervals will return the points at infinity toward which they are infinite in their result:

>>> complement (Levitate 3 :-: Top)
Just (Two (Bottom :|-|: Levitate 3) (Top :|-|: Top))

difference :: forall x. Ord x => Interval x -> Interval x -> Maybe (OneOrTwo (Interval x))

Remove all points of the second interval from the first.

>>> difference Whole (3 :<>: 4)
Just (Two (Bottom :|-|: Levitate 3) (Levitate 4 :|-|: Top))

>>> difference (1 :<>: 4) (2 :||: 3)
Just (Two (1 :<>: 2) (3 :<>: 4))

>>> difference (1 :|>: 4) (0 :||: 1)
Just (One (1 :<>: 4))

>>> difference (1 :<>: 4) (0 :||: 1)
Just (One (1 :<>: 4))

(\\) :: forall x. Ord x => Interval x -> Interval x -> Maybe (OneOrTwo (Interval x))

Infix synonym for difference

symmetricDifference :: forall x. Ord x => Interval x -> Interval x -> Maybe (OneOrTwo (Interval x))

The difference of the union and intersection of two intervals.

>>> symmetricDifference Whole (3 :<>: 4)
Just (Two (Bottom :|-|: Levitate 3) (Levitate 4 :|-|: Top))

>>> symmetricDifference (1 :<>: 4) (2 :||: 3)
Just (Two (1 :<>: 2) (3 :<>: 4))

measure :: forall x. (Ord x, Num x) => Interval x -> Maybe x

Get the measure of an interval.

>>> measure (-1 :<>: 1)
Just 2

>>> measure (Bottom :-: Levitate 1)
Nothing

measuring :: forall y x. (Ord x, Num y) => (x -> x -> y) -> Interval x -> Maybe y

Apply a function to the lower, then upper, endpoint of an interval.

>>> measuring max (-1 :<>: 1)
Just 1

>>> measuring min (-1 :<>: 1)
Just (-1)

>>> measuring (*) (4 :<>: 6)
Just 24

hausdorff :: (Ord x, Num x) => Interval x -> Interval x -> Maybe x

Get the distance between two intervals, or 0 if they adjacency.

>>> hausdorff (3 :<>: 5) (6 :<>: 7)
Just 1

>>> hausdorff (3 :<>: 5) Whole
Just 0

isSubsetOf :: Ord x => Interval x -> Interval x -> Bool

Full containment.

data OneOrTwo x

Either one of something, or two of it.

Use oneOrTwo to deconstruct.

Constructors

One !x

Two !x !x

Instances

Foldable OneOrTwo

Defined in Data.OneOrTwo

Methods

fold :: Monoid m => OneOrTwo m -> m

foldMap :: Monoid m => (a -> m) -> OneOrTwo a -> m

foldMap' :: Monoid m => (a -> m) -> OneOrTwo a -> m

foldr :: (a -> b -> b) -> b -> OneOrTwo a -> b

foldr' :: (a -> b -> b) -> b -> OneOrTwo a -> b

foldl :: (b -> a -> b) -> b -> OneOrTwo a -> b

foldl' :: (b -> a -> b) -> b -> OneOrTwo a -> b

foldr1 :: (a -> a -> a) -> OneOrTwo a -> a

foldl1 :: (a -> a -> a) -> OneOrTwo a -> a

toList :: OneOrTwo a -> [a]

null :: OneOrTwo a -> Bool

length :: OneOrTwo a -> Int

elem :: Eq a => a -> OneOrTwo a -> Bool

maximum :: Ord a => OneOrTwo a -> a

minimum :: Ord a => OneOrTwo a -> a

sum :: Num a => OneOrTwo a -> a

product :: Num a => OneOrTwo a -> a

Traversable OneOrTwo

Defined in Data.OneOrTwo

Methods

traverse :: Applicative f => (a -> f b) -> OneOrTwo a -> f (OneOrTwo b)

sequenceA :: Applicative f => OneOrTwo (f a) -> f (OneOrTwo a)

mapM :: Monad m => (a -> m b) -> OneOrTwo a -> m (OneOrTwo b)

sequence :: Monad m => OneOrTwo (m a) -> m (OneOrTwo a)

Functor OneOrTwo

Defined in Data.OneOrTwo

Methods

fmap :: (a -> b) -> OneOrTwo a -> OneOrTwo b

(<$) :: a -> OneOrTwo b -> OneOrTwo a

Data x => Data (OneOrTwo x)

Defined in Data.OneOrTwo

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OneOrTwo x -> c (OneOrTwo x)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (OneOrTwo x)

toConstr :: OneOrTwo x -> Constr

dataTypeOf :: OneOrTwo x -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (OneOrTwo x))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (OneOrTwo x))

gmapT :: (forall b. Data b => b -> b) -> OneOrTwo x -> OneOrTwo x

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OneOrTwo x -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OneOrTwo x -> r

gmapQ :: (forall d. Data d => d -> u) -> OneOrTwo x -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> OneOrTwo x -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OneOrTwo x -> m (OneOrTwo x)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OneOrTwo x -> m (OneOrTwo x)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OneOrTwo x -> m (OneOrTwo x)

Generic (OneOrTwo x)

Defined in Data.OneOrTwo

Associated Types

type Rep (OneOrTwo x) :: Type -> Type

Methods

from :: OneOrTwo x -> Rep (OneOrTwo x) x0

to :: Rep (OneOrTwo x) x0 -> OneOrTwo x

Read x => Read (OneOrTwo x)

Defined in Data.OneOrTwo

Methods

readsPrec :: Int -> ReadS (OneOrTwo x)

readList :: ReadS [OneOrTwo x]

readPrec :: ReadPrec (OneOrTwo x)

readListPrec :: ReadPrec [OneOrTwo x]

Show x => Show (OneOrTwo x)

Defined in Data.OneOrTwo

Methods

showsPrec :: Int -> OneOrTwo x -> ShowS

show :: OneOrTwo x -> String

showList :: [OneOrTwo x] -> ShowS

Eq x => Eq (OneOrTwo x)

Defined in Data.OneOrTwo

Methods

(==) :: OneOrTwo x -> OneOrTwo x -> Bool

(/=) :: OneOrTwo x -> OneOrTwo x -> Bool

Ord x => Ord (OneOrTwo x)

Defined in Data.OneOrTwo

Methods

compare :: OneOrTwo x -> OneOrTwo x -> Ordering

(<) :: OneOrTwo x -> OneOrTwo x -> Bool

(<=) :: OneOrTwo x -> OneOrTwo x -> Bool

(>) :: OneOrTwo x -> OneOrTwo x -> Bool

(>=) :: OneOrTwo x -> OneOrTwo x -> Bool

max :: OneOrTwo x -> OneOrTwo x -> OneOrTwo x

min :: OneOrTwo x -> OneOrTwo x -> OneOrTwo x

type Rep (OneOrTwo x)

Defined in Data.OneOrTwo

type Rep (OneOrTwo x) = D1 ('MetaData "OneOrTwo" "Data.OneOrTwo" "interval-patterns-0.6.0.1-AWVGvVImLF665RHNyYdFZ" 'False) (C1 ('MetaCons "One" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 x)) :+: C1 ('MetaCons "Two" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 x) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 x)))