-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Intervals, and monoids thereof
--   
--   Please see the README at
--   <a>https://github.com/mixphix/interval-patterns</a>
@package interval-patterns
@version 0.7.0.1

module Data.OneOrTwo

-- | Either one of something, or two of it.
--   
--   Use <a>oneOrTwo</a> to deconstruct.
data OneOrTwo x
One :: !x -> OneOrTwo x
Two :: !x -> !x -> OneOrTwo x

-- | Apply a <a>oneOrTwo</a> argument function appropriately.
oneOrTwo :: (x -> a) -> (x -> x -> a) -> OneOrTwo x -> a
instance Data.Traversable.Traversable Data.OneOrTwo.OneOrTwo
instance Data.Foldable.Foldable Data.OneOrTwo.OneOrTwo
instance GHC.Base.Functor Data.OneOrTwo.OneOrTwo
instance Data.Data.Data x => Data.Data.Data (Data.OneOrTwo.OneOrTwo x)
instance GHC.Generics.Generic (Data.OneOrTwo.OneOrTwo x)
instance GHC.Read.Read x => GHC.Read.Read (Data.OneOrTwo.OneOrTwo x)
instance GHC.Show.Show x => GHC.Show.Show (Data.OneOrTwo.OneOrTwo x)
instance GHC.Classes.Ord x => GHC.Classes.Ord (Data.OneOrTwo.OneOrTwo x)
instance GHC.Classes.Eq x => GHC.Classes.Eq (Data.OneOrTwo.OneOrTwo x)


-- | Intervals over types and their operations.
module Data.Interval

-- | The kinds of extremum an interval can have.
data Extremum
Minimum :: Extremum
Infimum :: Extremum
Supremum :: Extremum
Maximum :: Extremum

-- | The <a>opposite</a> of an <a>Extremum</a> is its complementary
--   analogue: how the same point would be viewed from the complement of
--   the interval to which it belongs.
--   
--   c.f. <a>opposeBound</a>.
opposite :: Extremum -> Extremum

-- | A <a>Bound</a> is an endpoint of an <a>Interval</a>.
data Bound ext x
[Min] :: !x -> Bound Minimum x
[Inf] :: !x -> Bound Infimum x
[Sup] :: !x -> Bound Supremum x
[Max] :: !x -> Bound Maximum x

-- | Extract the term from a <a>Bound</a>.
unBound :: Bound ext x -> x

-- | A type class for inverting <a>Bound</a>s.
class (Opposite (Opposite ext) ~ ext) => Bounding ext where {
    type Opposite ext :: Extremum;
}
bound :: Bounding ext => x -> Bound ext x

-- | c.f. <a>opposite</a>.
opposeBound :: Bounding ext => Bound ext x -> Bound (Opposite ext) x

-- | <a>Bound</a>s have special comparison rules for identical points.
--   
--   <pre>
--   &gt;&gt;&gt; compareBounds (Min (Levitate 5)) (Max (Levitate 5))
--   EQ
--   
--   &gt;&gt;&gt; compareBounds (Inf (Levitate 5)) (Sup (Levitate 5))
--   GT
--   
--   &gt;&gt;&gt; compareBounds (Max (Levitate 5)) (Sup (Levitate 5))
--   GT
--   
--   &gt;&gt;&gt; compareBounds (Inf (Levitate 5)) (Min (Levitate 5))
--   GT
--   
--   &gt;&gt;&gt; compareBounds (Max (Levitate 5)) (Inf (Levitate 5))
--   LT
--   </pre>
compareBounds :: Ord x => Bound ext1 x -> Bound ext2 x -> Ordering
data SomeBound x
SomeBound :: !Bound ext x -> SomeBound x
unSomeBound :: Ord x => SomeBound x -> x
oppose :: SomeBound x -> SomeBound x
data Interval x
[:<-->:] :: Ord x => !Bound Infimum (Levitated x) -> !Bound Supremum (Levitated x) -> Interval x
[:<--|:] :: Ord x => !Bound Infimum (Levitated x) -> !Bound Maximum (Levitated x) -> Interval x
[:|-->:] :: Ord x => !Bound Minimum (Levitated x) -> !Bound Supremum (Levitated x) -> Interval x
[:|--|:] :: Ord x => !Bound Minimum (Levitated x) -> !Bound Maximum (Levitated x) -> Interval x
infix 5 :<-->:
infix 5 :<--|:
infix 5 :|-->:
infix 5 :|--|:

-- | Since the <a>Ord</a> constraints on the constructors for
--   <a>Interval</a> prevent it from being a <a>Functor</a>, this will have
--   to suffice.
imap :: (Ord x, Ord y) => (x -> y) -> Interval x -> Interval y

-- | Same as <a>imap</a> but on the <a>Levitated</a> of the underlying
--   type.
imapLev :: (Ord x, Ord y) => (Levitated x -> Levitated y) -> Interval x -> Interval y

-- | Since the <a>Ord</a> constraints on the constructors for
--   <a>Interval</a> prevent it from being <a>Traversable</a>, this will
--   have to suffice.
itraverse :: (Ord x, Ord y, Applicative f) => (x -> f y) -> Interval x -> f (Interval y)

-- | Same as <a>itraverse</a> but on the <a>Levitated</a> of the underlying
--   type.
itraverseLev :: (Ord x, Ord y, Applicative f) => (Levitated x -> f (Levitated y)) -> Interval x -> f (Interval y)

-- | 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 (:|-|:) :: Ord x => Levitated x -> Levitated x -> Interval x
infix 5 :|-|:

-- | A unidirectional pattern synonym ignoring the particular
--   <a>Bound</a>s.
pattern (:---:) :: forall x. Ord x => Levitated x -> Levitated x -> Interval x

-- | 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
infix 5 :||:

-- | A unidirectional pattern synonym matching finite intervals, that
--   ignores the particular <a>Bound</a>s.
pattern (:--:) :: forall x. Ord x => x -> x -> Interval x

-- | The whole interval.
pattern Whole :: Ord x => Interval x

-- | <tt>m <a>+/-</a> r</tt> creates the closed interval centred at
--   <tt>m</tt> with radius <tt>r</tt>.
--   
--   For the open interval, simply write <tt><a>open</a> (x <a>+/-</a>
--   y)</tt>.
(+/-) :: (Ord x, Num x) => x -> x -> Interval x

-- | Given limits and <a>Extremum</a>s, try to make an interval.
(...) :: Ord x => (Levitated x, Extremum) -> (Levitated x, Extremum) -> Interval x

-- | Get the <tt>(lower, upper)</tt> <a>bounds</a> of an <a>Interval</a>.
--   
--   c.f. <a>lower</a>, <a>upper</a>.
bounds :: Interval x -> (SomeBound (Levitated x), SomeBound (Levitated x))

-- | Get the lower bound of an interval.
--   
--   <pre>
--   lower = fst . bounds
--   </pre>
lower :: Ord x => Interval x -> SomeBound (Levitated x)

-- | Get the lower bound of an interval (with the bound expressed at the
--   term level).
lowerBound :: Ord x => Interval x -> (Levitated x, Extremum)

-- | Get the upper bound of an interval.
--   
--   <pre>
--   upper = snd . bounds
--   </pre>
upper :: Ord x => Interval x -> SomeBound (Levitated x)

-- | Get the upper bound of an interval (with the bound expressed at the
--   term level).
upperBound :: Ord x => Interval x -> (Levitated x, Extremum)

-- | Given <a>SomeBound</a>s, try to make an interval.
interval :: Ord x => SomeBound (Levitated x) -> SomeBound (Levitated x) -> Interval x

-- | Get the minimum of an interval, if it exists.
imin :: Ord x => Interval x -> Maybe (Levitated x)

-- | Get the infimum of an interval, weakening if necessary.
iinf :: Ord x => Interval x -> Levitated x

-- | Get the supremum of an interval, weakening if necessary.
isup :: Ord x => Interval x -> Levitated x

-- | Get the maximum of an interval if it exists.
imax :: Ord x => Interval x -> Maybe (Levitated x)

-- | Get the convex hull of two intervals.
--   
--   <pre>
--   &gt;&gt;&gt; hull (7 :|&gt;: 8) (3 :|&gt;: 4)
--   (3 :|&gt;: 8)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; hull (Bottom :&lt;-|: Levitate 3) (4 :&lt;&gt;: 5)
--   (Bottom :&lt;-&gt;: Levitate 5)
--   </pre>
hull :: Ord x => Interval x -> Interval x -> Interval x

-- | Get the convex hull of a non-empty list of intervals.
hulls :: Ord x => NonEmpty (Interval x) -> Interval x

-- | Test whether a point is contained in the interval.
within :: Ord x => x -> Interval x -> Bool

-- | Create the closed-closed interval at a given point.
point :: Ord x => x -> Interval x

-- | Open both bounds of the given interval.
open :: Ord x => Interval x -> Interval x

-- | Close both bounds of the given interval.
close :: Ord x => Interval x -> Interval x

-- | Make the interval open-closed, leaving the endpoints unchanged.
openclosed :: Ord x => Interval x -> Interval x

-- | Make the interval closed-open, leaving the endpoints unchanged.
closedopen :: Ord x => Interval x -> Interval x

-- | Make the lower bound open, leaving the endpoints unchanged.
openLower :: Ord x => Interval x -> Interval x

-- | Make the lower bound closed, leaving the endpoints unchanged.
closedLower :: Ord x => Interval x -> Interval x

-- | Make the upper bound open, leaving the endpoints unchanged.
openUpper :: Ord x => Interval x -> Interval x

-- | Make the upper bound closed, leaving the endpoints unchanged.
closedUpper :: Ord x => Interval x -> Interval x
setLower :: Ord x => Levitated x -> Interval x -> Interval x
setUpper :: Ord x => Levitated x -> Interval x -> Interval x

-- | According to <a>Allen</a>, two intervals can be "adjacent" in 13
--   different ways, into at most 3 distinct intervals. In this package,
--   this quality is called the <a>Adjacency</a> of the intervals.
data Adjacency x
Before :: !Interval x -> !Interval x -> Adjacency x
Meets :: !Interval x -> !Interval x -> !Interval x -> Adjacency x
Overlaps :: !Interval x -> !Interval x -> !Interval x -> Adjacency x
Starts :: !Interval x -> !Interval x -> Adjacency x
During :: !Interval x -> !Interval x -> !Interval x -> Adjacency x
Finishes :: !Interval x -> !Interval x -> Adjacency x
Identical :: !Interval x -> Adjacency x
FinishedBy :: !Interval x -> !Interval x -> Adjacency x
Contains :: !Interval x -> !Interval x -> !Interval x -> Adjacency x
StartedBy :: !Interval x -> !Interval x -> Adjacency x
OverlappedBy :: !Interval x -> !Interval x -> !Interval x -> Adjacency x
MetBy :: !Interval x -> !Interval x -> !Interval x -> Adjacency x
After :: !Interval x -> !Interval x -> Adjacency x

-- | The result of having compared the same two intervals in reverse order.
converseAdjacency :: Adjacency x -> Adjacency x

-- | Calculate the <a>Adjacency</a> between two intervals, according to
--   <a>Allen</a>.
adjacency :: Ord x => Interval x -> Interval x -> Adjacency x

-- | Calculate the intersection of two intervals, if it exists.
--   
--   <pre>
--   &gt;&gt;&gt; intersect (2 :&lt;&gt;: 4) (3 :||: 5)
--   Just (3 :|&gt;: 4)
--   
--   &gt;&gt;&gt; intersect (2 :&lt;&gt;: 4) (4 :||: 5)
--   Nothing
--   
--   &gt;&gt;&gt; intersect (1 :&lt;&gt;: 4) (2 :||: 3)
--   Just (2 :||: 3)
--   </pre>
intersect :: forall x. Ord x => Interval x -> Interval x -> Maybe (Interval x)

-- | Get the union of two intervals, as either <a>OneOrTwo</a>.
--   
--   <pre>
--   &gt;&gt;&gt; union (2 :||: 5) (5 :&lt;&gt;: 7)
--   One (Levitate 2 :|-&gt;: Levitate 7)
--   
--   &gt;&gt;&gt; union (2 :||: 4) (5 :&lt;&gt;: 7)
--   Two (Levitate 2 :|-|: Levitate 4) (Levitate 5 :<a>-</a>: Levitate 7)
--   </pre>
union :: forall x. Ord x => Interval x -> Interval x -> OneOrTwo (Interval x)

-- | <i>O(n log n)</i>. Get the union of a list of intervals.
--   
--   This function uses <a>sort</a>. See also <a>unionsAsc</a>.
unions :: forall x. Ord x => [Interval x] -> [Interval x]

-- | <i>O(n)</i>. Get the union of a sorted list of intervals.
--   
--   NOTE: The input condition is not checked. Use with care.
unionsAsc :: forall x. Ord x => [Interval x] -> [Interval x]

-- | Take the complement of the interval, as possibly <a>OneOrTwo</a>.
--   
--   <pre>
--   &gt;&gt;&gt; complement (3 :&lt;&gt;: 4)
--   Just (Two (Bottom :|-|: Levitate 3) (Levitate 4 :|-|: Top))
--   </pre>
--   
--   Note that infinitely-open intervals will return the points at infinity
--   toward which they are infinite in their result:
--   
--   <pre>
--   &gt;&gt;&gt; complement (Levitate 3 :<a>-</a>: Top)
--   Just (Two (Bottom :|-|: Levitate 3) (Top :|-|: Top))
--   </pre>
complement :: forall x. Ord x => Interval x -> Maybe (OneOrTwo (Interval x))

-- | Remove all points of the second interval from the first.
--   
--   <pre>
--   &gt;&gt;&gt; difference Whole (3 :&lt;&gt;: 4)
--   Just (Two (Bottom :|-|: Levitate 3) (Levitate 4 :|-|: Top))
--   
--   &gt;&gt;&gt; difference (1 :&lt;&gt;: 4) (2 :||: 3)
--   Just (Two (1 :&lt;&gt;: 2) (3 :&lt;&gt;: 4))
--   
--   &gt;&gt;&gt; difference (1 :|&gt;: 4) (0 :||: 1)
--   Just (One (1 :&lt;&gt;: 4))
--   
--   &gt;&gt;&gt; difference (1 :&lt;&gt;: 4) (0 :||: 1)
--   Just (One (1 :&lt;&gt;: 4))
--   </pre>
difference :: forall x. Ord x => Interval x -> Interval x -> Maybe (OneOrTwo (Interval x))

-- | Infix synonym for <a>difference</a>
(\\) :: forall x. Ord x => Interval x -> Interval x -> Maybe (OneOrTwo (Interval x))

-- | The difference of the union and intersection of two intervals.
--   
--   <pre>
--   &gt;&gt;&gt; symmetricDifference Whole (3 :&lt;&gt;: 4)
--   Just (Two (Bottom :|-|: Levitate 3) (Levitate 4 :|-|: Top))
--   
--   &gt;&gt;&gt; symmetricDifference (1 :&lt;&gt;: 4) (2 :||: 3)
--   Just (Two (1 :&lt;&gt;: 2) (3 :&lt;&gt;: 4))
--   </pre>
symmetricDifference :: forall x. Ord x => Interval x -> Interval x -> Maybe (OneOrTwo (Interval x))

-- | Get the measure of an interval.
--   
--   <pre>
--   &gt;&gt;&gt; measure (-1 :&lt;&gt;: 1)
--   Just 2
--   
--   &gt;&gt;&gt; measure (Bottom :<a>-</a>: Levitate 1)
--   Nothing
--   </pre>
measure :: forall x. (Ord x, Num x) => Interval x -> Maybe x

-- | Apply a function to the lower, then upper, endpoint of an interval.
--   
--   <pre>
--   &gt;&gt;&gt; measuring max (-1 :&lt;&gt;: 1)
--   Just 1
--   
--   &gt;&gt;&gt; measuring min (-1 :&lt;&gt;: 1)
--   Just (-1)
--   
--   &gt;&gt;&gt; measuring (*) (4 :&lt;&gt;: 6)
--   Just 24
--   </pre>
measuring :: forall y x. (Ord x, Num y) => (x -> x -> y) -> Interval x -> Maybe y

-- | Get the distance between two intervals, or 0 if they adjacency.
--   
--   <pre>
--   &gt;&gt;&gt; hausdorff (3 :&lt;&gt;: 5) (6 :&lt;&gt;: 7)
--   Just 1
--   
--   &gt;&gt;&gt; hausdorff (3 :&lt;&gt;: 5) Whole
--   Just 0
--   </pre>
hausdorff :: (Ord x, Num x) => Interval x -> Interval x -> Maybe x

-- | Full containment.
isSubsetOf :: Ord x => Interval x -> Interval x -> Bool

-- | Either one of something, or two of it.
--   
--   Use <a>oneOrTwo</a> to deconstruct.
data OneOrTwo x
One :: !x -> OneOrTwo x
Two :: !x -> !x -> OneOrTwo x
instance Data.Data.Data Data.Interval.Extremum
instance GHC.Generics.Generic Data.Interval.Extremum
instance GHC.Read.Read Data.Interval.Extremum
instance GHC.Show.Show Data.Interval.Extremum
instance GHC.Enum.Bounded Data.Interval.Extremum
instance GHC.Enum.Enum Data.Interval.Extremum
instance GHC.Classes.Ord Data.Interval.Extremum
instance GHC.Classes.Eq Data.Interval.Extremum
instance (Data.Data.Data x, GHC.Classes.Ord x) => Data.Data.Data (Data.Interval.Adjacency x)
instance GHC.Generics.Generic (Data.Interval.Adjacency x)
instance (GHC.Classes.Ord x, GHC.Show.Show x) => GHC.Show.Show (Data.Interval.Adjacency x)
instance GHC.Classes.Ord x => GHC.Classes.Ord (Data.Interval.Adjacency x)
instance GHC.Classes.Ord x => GHC.Classes.Eq (Data.Interval.Adjacency x)
instance GHC.Classes.Ord x => GHC.Classes.Eq (Data.Interval.Interval x)
instance (GHC.Classes.Ord x, GHC.Show.Show x) => GHC.Show.Show (Data.Interval.Interval x)
instance GHC.Classes.Ord x => GHC.Classes.Ord (Data.Interval.Interval x)
instance (GHC.Classes.Ord x, Data.Data.Data x) => Data.Data.Data (Data.Interval.Interval x)
instance (GHC.Classes.Ord x, GHC.Generics.Generic x) => GHC.Generics.Generic (Data.Interval.Interval x)
instance GHC.Classes.Eq x => GHC.Classes.Eq (Data.Interval.SomeBound (Algebra.Lattice.Levitated.Levitated x))
instance GHC.Classes.Ord x => GHC.Classes.Ord (Data.Interval.SomeBound (Algebra.Lattice.Levitated.Levitated x))
instance Data.Interval.Bounding 'Data.Interval.Minimum
instance Data.Interval.Bounding 'Data.Interval.Infimum
instance Data.Interval.Bounding 'Data.Interval.Supremum
instance Data.Interval.Bounding 'Data.Interval.Maximum
instance GHC.Base.Functor (Data.Interval.Bound ext)
instance Data.Foldable.Foldable (Data.Interval.Bound ext)
instance Data.Traversable.Traversable (Data.Interval.Bound ext)
instance GHC.Classes.Eq x => GHC.Classes.Eq (Data.Interval.Bound ext x)
instance GHC.Classes.Ord x => GHC.Classes.Ord (Data.Interval.Bound ext (Algebra.Lattice.Levitated.Levitated x))

module Data.Interval.Borel

-- | The <a>Borel</a> sets on a type are the sets generated by its
--   intervals. It forms a <a>Heyting</a> algebra with <a>union</a> as join
--   and <a>intersection</a> as meet, and a <a>Ring</a> with
--   <a>symmetricDifference</a> as addition and <a>intersection</a> as
--   multiplication (and <a>complement</a> as negation). In fact the
--   algebra is Boolean as the operation <tt>x <a>==&gt;</a> y =
--   <a>complement</a> x <a>\/</a> y</tt>.
--   
--   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 <a>Layers</a>.
data Borel x

-- | Consider the <a>Borel</a> set identified by a list of
--   <a>Interval</a>s.
borel :: Ord x => [Interval x] -> Borel x

-- | Turn a <a>Borel</a> set into a <a>Set</a> of <a>Interval</a>s.
intervalSet :: Ord x => Borel x -> Set (Interval x)

-- | The empty <a>Borel</a> set.
empty :: Ord x => Borel x

-- | The <a>Borel</a> set consisting of a single <a>Interval</a>.
singleton :: Ord x => Interval x -> Borel x

-- | Is this <a>Borel</a> set empty?
null :: Borel x -> Bool

-- | Insert an <a>Interval</a> into a <a>Borel</a> set, agglomerating along
--   the way.
insert :: Ord x => Interval x -> Borel x -> Borel x

-- | The maximal <a>Borel</a> set, that covers the entire range.
whole :: Ord x => Borel x

-- | Completely remove an <a>Interval</a> from a <a>Borel</a> set.
--   Essentially the opposite of <a>truncate</a>.
remove :: Ord x => Interval x -> Borel x -> Borel x

-- | Flipped infix version of <a>remove</a>.
(\-) :: Ord x => Borel x -> Interval x -> Borel x

-- | Given an <a>Interval</a> <tt>i</tt>, <tt><a>truncate</a> i</tt> will
--   trim a <a>Borel</a> set so that its <a>hull</a> is contained in
--   <tt>i</tt>.
truncate :: Ord x => Interval x -> Borel x -> Borel x

-- | Flipped infix version of <a>truncate</a>.
(\=) :: Ord x => Borel x -> Interval x -> Borel x

-- | Is this point <a>within</a> any connected component of the
--   <a>Borel</a> set?
member :: Ord x => x -> Borel x -> Bool

-- | Is this point not <a>within</a> any connected component of the
--   <a>Borel</a> set?
notMember :: Ord x => x -> Borel x -> Bool

-- | A synonym for <a>(&lt;&gt;)</a>.
union :: Ord x => Borel x -> Borel x -> Borel x

-- | A synonym for <a>fold</a>.
unions :: Ord x => [Borel x] -> Borel x

-- | Remove all intervals of the second set from the first.
difference :: Ord x => Borel x -> Borel x -> Borel x

-- | Take the symmetric difference of two <a>Borel</a> sets.
symmetricDifference :: Ord x => Borel x -> Borel x -> Borel x

-- | Take the <a>Borel</a> set consisting of each point not in the given
--   one.
complement :: Ord x => Borel x -> Borel x

-- | Take the intersection of two <a>Borel</a> sets.
intersection :: Ord x => Borel x -> Borel x -> Borel x

-- | Take the intersection of a list of <a>Borel</a> sets.
intersections :: Ord x => [Borel x] -> Borel x

-- | Take the smallest spanning <a>Interval</a> of a <a>Borel</a> set,
--   provided that it is not the empty set.
hull :: Ord x => Borel x -> Maybe (Interval x)
isSubsetOf :: Ord x => Borel x -> Borel x -> Bool
instance (Data.Data.Data x, GHC.Classes.Ord x) => Data.Data.Data (Data.Interval.Borel.Borel x)
instance GHC.Generics.Generic (Data.Interval.Borel.Borel x)
instance (GHC.Classes.Ord x, GHC.Show.Show x) => GHC.Show.Show (Data.Interval.Borel.Borel x)
instance GHC.Classes.Ord x => GHC.Classes.Ord (Data.Interval.Borel.Borel x)
instance GHC.Classes.Ord x => GHC.Classes.Eq (Data.Interval.Borel.Borel x)
instance GHC.Classes.Ord x => GHC.Base.Semigroup (Data.Interval.Borel.Borel x)
instance GHC.Classes.Ord x => GHC.Base.Monoid (Data.Interval.Borel.Borel x)
instance (GHC.Classes.Ord x, Algebra.Lattice.Lattice x) => Algebra.Lattice.Lattice (Data.Interval.Borel.Borel x)
instance (GHC.Classes.Ord x, Algebra.Lattice.Lattice x) => Algebra.Lattice.BoundedMeetSemiLattice (Data.Interval.Borel.Borel x)
instance (GHC.Classes.Ord x, Algebra.Lattice.Lattice x) => Algebra.Lattice.BoundedJoinSemiLattice (Data.Interval.Borel.Borel x)
instance (GHC.Classes.Ord x, Algebra.Lattice.Lattice x) => Algebra.Heyting.Heyting (Data.Interval.Borel.Borel x)
instance (GHC.Classes.Ord x, Algebra.Lattice.Lattice x) => Data.Semiring.Semiring (Data.Interval.Borel.Borel x)
instance (GHC.Classes.Ord x, Algebra.Lattice.Lattice x) => Data.Semiring.Ring (Data.Interval.Borel.Borel x)

module Data.Interval.Layers
data Layers x y

-- | Draw the <a>Layers</a> of specified bases and thicknesses.
fromList :: (Ord x, Ord y, Semigroup y) => [(Interval x, y)] -> Layers x y

-- | Get all of the bases and thicknesses in the <a>Layers</a>.
toList :: Ord x => Layers x y -> [(Interval x, y)]

-- | A blank canvas.
empty :: Layers x y

-- | <tt>singleton ix y</tt> is the rectangle with base <tt>ix</tt> of
--   thickness <tt>y</tt>.
singleton :: Ord x => Interval x -> y -> Layers x y

-- | <tt>insert ix y l</tt> draws over <tt>l</tt> a rectangle with base
--   <tt>ix</tt> of thickness <tt>y</tt>.
insert :: (Ord x, Ord y, Semigroup y) => Interval x -> y -> Layers x y -> Layers x y

-- | Flipped synonym for <a>insert</a>. Mnemonic: "pile" this much onto the
--   existing <a>Layers</a> over the given <a>Interval</a>.
pile :: (Ord x, Ord y, Semigroup y) => y -> Interval x -> Layers x y -> Layers x y

-- | Ignore the <a>Layers</a> and focus only on whether points are
--   <tt>within</tt> any contained <a>Interval</a> or not.
squash :: Ord x => Layers x y -> Borel x

-- | Get the thickness of the <a>Layers</a> at a point.
thickness :: (Ord x, Monoid y) => x -> Layers x y -> y

-- | Where and how thick is the thickest <a>Interval</a>?
thickest :: (Ord x, Ord y) => Layers x y -> Maybe (Interval x, y)

-- | Take away a thickness over a given base from the <a>Layers</a>.
dig :: (Ord x, Ord y, Group y) => y -> Interval x -> Layers x y -> Layers x y

-- | Completely remove an <a>Interval</a> from the <a>Layers</a>.
remove :: (Ord x, Ord y, Semigroup y) => Interval x -> Layers x y -> Layers x y

-- | Fliped infix version of <a>remove</a>.
(\-) :: (Ord x, Ord y, Semigroup y) => Layers x y -> Interval x -> Layers x y

-- | Add the given thickness to every point.
baseline :: (Ord x, Ord y, Semigroup y) => y -> Layers x y -> Layers x y

-- | <a>Excavate</a> the second argument from the first.
difference :: (Ord x, Ord y, Group y) => Layers x y -> Layers x y -> Layers x y

-- | Restrict the range of the <a>Layers</a> to the given <a>Interval</a>.
truncate :: (Ord x, Ord y, Semigroup y) => Interval x -> Layers x y -> Layers x y

-- | Flipped infix version of <a>truncate</a>.
(\=) :: (Ord x, Ord y, Semigroup y) => Layers x y -> Interval x -> Layers x y

-- | Convert the <a>Layers</a> into a list of beginning-points and heights,
--   that define a step function piecewise.
toStepFunction :: (Ord x, Ord y, Monoid y) => Layers x y -> [(Levitated x, y)]

-- | <tt><a>integrate</a> diff hgt ix l</tt> calculates the area under the
--   <a>Interval</a> <tt>ix</tt> using the measure <tt>diff</tt> of the
--   interval multiplied by the height <tt>hgt</tt> of the layers over each
--   sub-interval in the layers.
integrate :: (Ord x, Ord y, Semigroup y, Num z) => (x -> x -> z) -> (y -> z) -> Interval x -> Layers x y -> Maybe z
nestings :: (Ord x, Ord y, Semigroup y) => [(Interval x, y)] -> [(Interval x, y)]
instance (Data.Data.Data x, Data.Data.Data y, GHC.Classes.Ord x) => Data.Data.Data (Data.Interval.Layers.Layers x y)
instance GHC.Generics.Generic (Data.Interval.Layers.Layers x y)
instance GHC.Base.Functor (Data.Interval.Layers.Layers x)
instance (GHC.Classes.Ord x, GHC.Show.Show x, GHC.Show.Show y) => GHC.Show.Show (Data.Interval.Layers.Layers x y)
instance (GHC.Classes.Ord x, GHC.Classes.Ord y) => GHC.Classes.Ord (Data.Interval.Layers.Layers x y)
instance (GHC.Classes.Ord x, GHC.Classes.Eq y) => GHC.Classes.Eq (Data.Interval.Layers.Layers x y)
instance (GHC.Classes.Ord x, GHC.Classes.Ord y, GHC.Base.Semigroup y) => GHC.Base.Semigroup (Data.Interval.Layers.Layers x y)
instance (GHC.Classes.Ord x, GHC.Classes.Ord y, GHC.Base.Semigroup y) => GHC.Base.Monoid (Data.Interval.Layers.Layers x y)
instance (GHC.Classes.Ord x, GHC.Classes.Ord y, Data.Group.Group y) => Data.Group.Group (Data.Interval.Layers.Layers x y)

module Data.Timeframe

-- | <pre>
--   type Timeframe = Interval UTCTime
--   </pre>
type Timeframe = Interval UTCTime
localTimeframeAt :: TimeZone -> LocalTime -> LocalTime -> Timeframe
localTimeframe :: MonadIO io => LocalTime -> LocalTime -> io Timeframe
pureLocalTimeframe :: LocalTime -> LocalTime -> Timeframe
duration :: Timeframe -> Maybe NominalDiffTime

module Data.Calendar

-- | An <a>Event</a> is a collection of <a>Timeframe</a>s that keeps track
--   of how deeply a particular interval has been overlapped.
--   
--   <pre>
--   type Event n = Layers UTCTime (Sum n)
--   </pre>
type Event n = Layers UTCTime (Sum n)

-- | Make a new <a>Event</a> from a <a>Timeframe</a> with default thickness
--   1.
--   
--   <pre>
--   event = eventSize 1
--   </pre>
event :: Num n => Timeframe -> Event n

-- | Make an <a>Event</a> with the given size from a <a>Timeframe</a>.
eventSize :: Num n => n -> Timeframe -> Event n

-- | Measure the carried load of an <a>Event</a> over a given
--   <a>Timeframe</a>. In other words: how many copies of you would you
--   need, in order to attend all of the simultaneous happenings over a
--   given span (on average)?
erlangs :: Real n => Timeframe -> Event n -> Maybe Rational

-- | A <a>Calendar</a> is a map from a given event type to durations.
newtype Calendar ev n
Calendar :: Map ev (Event n) -> Calendar ev n
[getCalendar] :: Calendar ev n -> Map ev (Event n)

-- | Make a <a>Calendar</a> from an <a>Event</a>.
singleton :: (Ord ev, Ord n, Num n) => ev -> Event n -> Calendar ev n

-- | Make a <a>Calendar</a> from a <a>Timeframe</a>.
calendar :: (Ord ev, Ord n, Num n) => ev -> Timeframe -> Calendar ev n

-- | Insert an <a>Event</a> of the given sort into a <a>Calendar</a>.
insert :: (Ord ev, Ord n, Num n) => ev -> Event n -> Calendar ev n -> Calendar ev n

-- | Get the <a>Event</a> corresponding to a given key, or <a>Nothing</a>
--   if the key is not present.
(!?) :: (Ord ev, Ord n, Num n) => Calendar ev n -> ev -> Maybe (Event n)

-- | Get the <a>Event</a> corresponding to a given key, or <a>mempty</a> if
--   the key is not present.
(!) :: (Ord ev, Ord n, Num n) => Calendar ev n -> ev -> Event n
toList :: (Ord ev, Ord n, Num n) => Calendar ev n -> [(ev, [(Interval UTCTime, n)])]

-- | What, and how many events are happening at the given <a>UTCTime</a> on
--   this <a>Calendar</a>?
happeningAt :: (Ord ev, Ord n, Num n) => UTCTime -> Calendar ev n -> [(ev, n)]

-- | Consider every kind of event the same, and observe the overall
--   <a>Layers</a>.
coalesce :: (Ord ev, Ord n, Num n) => Calendar ev n -> Event n
totalDuration :: forall ev n. (Ord ev, Real n) => ev -> Calendar ev n -> Maybe NominalDiffTime
instance (GHC.Show.Show ev, GHC.Show.Show n) => GHC.Show.Show (Data.Calendar.Calendar ev n)
instance (GHC.Classes.Ord ev, GHC.Classes.Ord n) => GHC.Classes.Ord (Data.Calendar.Calendar ev n)
instance (GHC.Classes.Eq ev, GHC.Classes.Eq n) => GHC.Classes.Eq (Data.Calendar.Calendar ev n)
instance (GHC.Classes.Ord ev, GHC.Classes.Ord n, GHC.Num.Num n) => GHC.Base.Semigroup (Data.Calendar.Calendar ev n)
instance (GHC.Classes.Ord ev, GHC.Classes.Ord n, GHC.Num.Num n) => GHC.Base.Monoid (Data.Calendar.Calendar ev n)