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


-- | A library for easy manipulation of intervals according to their
--   overlap.
@package interval-patterns
@version 0.1.0.0

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 extremum is how it would be viewed from the
--   other "direction" of how it is currently.
--   
--   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 family 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.
--   
--   <ul>
--   <li>minima are lesser than infima</li>
--   <li>suprema are lesser than maxima</li>
--   <li>infima and minima are both lesser than suprema and maxima</li>
--   </ul>
compareBounds :: Ord x => Bound ext1 (Levitated x) -> Bound ext2 (Levitated 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.
imapS :: (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.
itraverseS :: (Ord x, Ord y, Applicative f) => (Levitated x -> f (Levitated y)) -> Interval x -> f (Interval y)

-- | A pattern synonym matching open intervals.
pattern (:<->:) :: Ord x => Levitated x -> Levitated x -> Interval x
infix 5 :<->:

-- | A pattern synonym matching open-closed intervals.
pattern (:<-|:) :: Ord x => Levitated x -> Levitated x -> Interval x
infix 5 :<-|:

-- | A pattern synonym matching closed-open intervals.
pattern (:|->:) :: Ord x => Levitated x -> Levitated x -> Interval x
infix 5 :|->:

-- | A pattern synonym matching closed intervals.
pattern (:|-|:) :: Ord x => Levitated x -> Levitated x -> Interval x
infix 5 :|-|:

-- | A pattern synonym matching finite open intervals.
pattern (:<>:) :: forall x. Ord x => x -> x -> Interval x
infix 5 :<>:

-- | A pattern synonym matching finite open-closed intervals.
pattern (:<|:) :: forall x. Ord x => x -> x -> Interval x
infix 5 :<|:

-- | A pattern synonym matching finite closed-open intervals.
pattern (:|>:) :: forall x. Ord x => x -> x -> Interval x
infix 5 :|>:

-- | A pattern synonym matching finite closed intervals.
pattern (:||:) :: forall x. Ord x => x -> x -> Interval x
infix 5 :||:

-- | The whole interval.
pattern Whole :: Ord x => 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 (Bound Minimum (Levitated x))

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

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

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

-- | Get the convex hull of two intervals.
--   
--   <pre>
--   &gt;&gt;&gt; hull (7 :|&gt;: 8) (3 :|&gt;: 4)
--   (Levitate 3 :|-&gt;: Levitate 8)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; hull (Bottom :&lt;-|: 3) (3 :&lt;|: 4)
--   (Bottom :&lt;-|: Levitate 4)
--   </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 (Levitate 3 :|-&gt;: Levitate 4)
--   
--   &gt;&gt;&gt; intersect (2 :&lt;&gt;: 4) (4 :||: 5)
--   Nothing
--   
--   &gt;&gt;&gt; intersect (1 :&lt;&gt;: 4) (2 :||: 3)
--   Just (Levitate 2 :|-|: Levitate 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>
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 (Levitate 1 :<a>-</a>: Levitate 2) (Levitate 3 :<a>-</a>: Levitate 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 (Levitate 1 :<a>-</a>: Levitate 2) (Levitate 3 :<a>-</a>: Levitate 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)
--   </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

-- | <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
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 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.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 open
--   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.
cutout :: Ord x => Interval x -> Borel 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)
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 => Relude.Container.One.One (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, 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, Semigroup y) => Interval x -> y -> 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>.
remove :: (Ord x, Group y) => y -> Interval x -> Layers x y -> Layers x y

-- | Add the given thickness to every point.
baseline :: (Ord x, Semigroup y) => y -> Layers x y -> Layers x y
nestings :: (Ord x, Semigroup y) => [(Interval x, y)] -> [(Interval x, y)]
nestingsAsc :: (Ord x, Semigroup y) => [(Interval x, y)] -> [(Interval 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.Base.Semigroup y) => GHC.Base.Semigroup (Data.Interval.Layers.Layers x y)
instance (GHC.Classes.Ord x, GHC.Base.Semigroup y) => GHC.Base.Monoid (Data.Interval.Layers.Layers x y)
instance (GHC.Classes.Ord x, 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

-- | An <a>Event</a> is something that happens for a period of time.
--   
--   <pre>
--   type Event = Layers UTCTime
--   </pre>
type Event = Layers UTCTime (Sum Int)
event :: Timeframe -> Event
newtype Calendar ev
Calendar :: Map ev Event -> Calendar ev
[getCalendar] :: Calendar ev -> Map ev Event
singleton :: Ord ev => ev -> Event -> Calendar ev
calendar :: Ord ev => ev -> Timeframe -> Calendar ev
addEvent :: Ord ev => ev -> Event -> Calendar ev -> Calendar ev
totalDuration :: Ord ev => ev -> Calendar ev -> Maybe NominalDiffTime
instance GHC.Show.Show ev => GHC.Show.Show (Data.Timeframe.Calendar ev)
instance GHC.Classes.Ord ev => GHC.Classes.Ord (Data.Timeframe.Calendar ev)
instance GHC.Classes.Eq ev => GHC.Classes.Eq (Data.Timeframe.Calendar ev)
instance GHC.Classes.Ord ev => GHC.Base.Semigroup (Data.Timeframe.Calendar ev)
instance GHC.Classes.Ord ev => GHC.Base.Monoid (Data.Timeframe.Calendar ev)