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


-- | An implementation of Allen's interval algebra for temporal logic
--   
--   Please see the README on GitHub at
--   <a>https://github.com/novisci/interval-algebra</a>
@package interval-algebra
@version 2.0.2


-- | The <tt>IntervalAlgebra</tt> module provides data types and related
--   classes for the interval-based temporal logic described in <a>Allen
--   (1983)</a> and axiomatized in <a>Allen and Hayes (1987)</a>. A good
--   primer on Allen's algebra can be <a>found here</a>.
--   
--   <h1>Design</h1>
--   
--   The module is built around three typeclasses designed to separate
--   concerns of constructing, relating, and combining types that contain
--   <tt><a>Interval</a></tt>s:
--   
--   <ol>
--   <li><tt><a>Intervallic</a></tt> provides an interface to the data
--   structures which contain an <tt><a>Interval</a></tt>.</li>
--   <li><tt><a>IntervalCombinable</a></tt> provides an interface to
--   methods of combining two <tt><a>Interval</a>s</tt>.</li>
--   <li><tt><a>IntervalSizeable</a></tt> provides methods for measuring
--   and modifying the size of an interval.</li>
--   </ol>
module IntervalAlgebra.Core

-- | An <tt><a>Interval</a> a</tt> is a pair &lt;math&gt;. To create
--   intervals use the <tt><a>parseInterval</a></tt>,
--   <tt><a>beginerval</a></tt>, or <tt><a>enderval</a></tt> functions.
data Interval a

-- | The <tt><a>Intervallic</a></tt> typeclass defines how to get and set
--   the <a>Interval</a> content of a data structure. It also includes
--   functions for getting the endpoints of the <a>Interval</a> via
--   <tt><a>begin</a></tt> and <tt><a>end</a></tt>.
--   
--   <pre>
--   &gt;&gt;&gt; getInterval (Interval (0, 10))
--   (0, 10)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; begin (Interval (0, 10))
--   0
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; end (Interval (0, 10))
--   10
--   </pre>
class (Ord a) => Intervallic i a

-- | Get the interval from an <tt>i a</tt>.
getInterval :: Intervallic i a => i a -> Interval a

-- | Set the interval in an <tt>i a</tt>.
setInterval :: Intervallic i a => i a -> Interval a -> i a

-- | A type identifying interval parsing errors.
newtype ParseErrorInterval
ParseErrorInterval :: String -> ParseErrorInterval

-- | Access the endpoints of an <tt>i a</tt> .
begin :: Intervallic i a => i a -> a

-- | Access the endpoints of an <tt>i a</tt> .
end :: Intervallic i a => i a -> a

-- | Safely parse a pair of <tt>a</tt>s to create an <tt><a>Interval</a>
--   a</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; parseInterval 0 1
--   Right (0, 1)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; parseInterval 1 0
--   Left (ParseErrorInterval "0&lt;=1")
--   </pre>
parseInterval :: (Show a, Ord a) => a -> a -> Either ParseErrorInterval (Interval a)

-- | A synonym for <a>parseInterval</a>
prsi :: (Show a, Ord a) => a -> a -> Either ParseErrorInterval (Interval a)

-- | Safely creates an 'Interval a' using <tt>x</tt> as the <a>begin</a>
--   and adding <tt>max <a>moment</a> dur</tt> to <tt>x</tt> as the
--   <a>end</a>.
--   
--   <pre>
--   &gt;&gt;&gt; beginerval (0::Int) (0::Int)
--   (0, 1)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; beginerval (1::Int) (0::Int)
--   (0, 1)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; beginerval (2::Int) (0::Int)
--   (0, 2)
--   </pre>
beginerval :: forall a b. IntervalSizeable a b => b -> a -> Interval a

-- | A synonym for <a>beginerval</a>
bi :: IntervalSizeable a b => b -> a -> Interval a

-- | Safely creates an 'Interval a' using <tt>x</tt> as the <a>end</a> and
--   adding <tt>negate max <a>moment</a> dur</tt> to <tt>x</tt> as the
--   <a>begin</a>.
--   
--   <pre>
--   &gt;&gt;&gt; enderval (0::Int) (0::Int)
--   (-1, 0)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; enderval (1::Int) (0::Int)
--   (-1, 0)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; enderval (2::Int) (0::Int)
--   (-2, 0)
--   </pre>
enderval :: forall a b. IntervalSizeable a b => b -> a -> Interval a

-- | A synonym for <a>enderval</a>
ei :: IntervalSizeable a b => b -> a -> Interval a

-- | Safely creates an <tt><a>Interval</a></tt> from a pair of endpoints.
--   IMPORTANT: This function uses <a>beginerval</a>, thus if the second
--   element of the pair is <a>&lt;=</a> the first element, the duration
--   will be an <tt><a>Interval</a></tt> of <a>moment</a> duration.
--   
--   <pre>
--   &gt;&gt;&gt; safeInterval (4, 5 ::Int)
--   (4, 5)
--   
--   &gt;&gt;&gt; safeInterval (4, 3 :: Int)
--   (4, 5)
--   </pre>
safeInterval :: IntervalSizeable a b => (a, a) -> Interval a

-- | A synonym for <a>safeInterval</a>
si :: IntervalSizeable a b => (a, a) -> Interval a

-- | Resize an <tt>i a</tt> to by expanding to "left" by <tt>l</tt> and to
--   the "right" by <tt>r</tt>. In the case that <tt>l</tt> or <tt>r</tt>
--   are less than a <a>moment</a> the respective endpoints are unchanged.
--   
--   <pre>
--   &gt;&gt;&gt; expand 0 0 (Interval (0::Int, 2::Int))
--   (0, 2)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; expand 1 1 (Interval (0::Int, 2::Int))
--   (-1, 3)
--   </pre>
expand :: forall i a b. (IntervalSizeable a b, Intervallic i a) => b -> b -> i a -> i a

-- | Expands an <tt>i a</tt> to "left".
--   
--   <pre>
--   &gt;&gt;&gt; expandl 2 (Interval (0::Int, 2::Int))
--   (-2, 2)
--   </pre>
expandl :: (IntervalSizeable a b, Intervallic i a) => b -> i a -> i a

-- | Expands an <tt>i a</tt> to "right".
--   
--   <pre>
--   &gt;&gt;&gt; expandr 2 (Interval (0::Int, 2::Int))
--   (0, 4)
--   </pre>
expandr :: (IntervalSizeable a b, Intervallic i a) => b -> i a -> i a

-- | The <a>IntervalRelation</a> type and the associated predicate
--   functions enumerate the thirteen possible ways that two
--   <tt><a>Interval</a></tt> objects may <a>relate</a> according to
--   Allen's interval algebra. Constructors are shown with their
--   corresponding predicate function.
data IntervalRelation

-- | <a>before</a>
Before :: IntervalRelation

-- | <a>meets</a>
Meets :: IntervalRelation

-- | <a>overlaps</a>
Overlaps :: IntervalRelation

-- | <a>finishedBy</a>
FinishedBy :: IntervalRelation

-- | <a>contains</a>
Contains :: IntervalRelation

-- | <a>starts</a>
Starts :: IntervalRelation

-- | <a>equals</a>
Equals :: IntervalRelation

-- | <a>startedBy</a>
StartedBy :: IntervalRelation

-- | <a>during</a>
During :: IntervalRelation

-- | <a>finishes</a>
Finishes :: IntervalRelation

-- | <a>overlappedBy</a>
OverlappedBy :: IntervalRelation

-- | <a>metBy</a>
MetBy :: IntervalRelation

-- | <a>after</a>
After :: IntervalRelation

-- | Does x <a>meets</a> y? Is x metBy y?
meets :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Does x <a>meets</a> y? Is x metBy y?
metBy :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Is x before y? Is x after y?
before :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Is x before y? Is x after y?
after :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Does x overlap y? Is x overlapped by y?
overlaps :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Does x overlap y? Is x overlapped by y?
overlappedBy :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Does x finish y? Is x finished by y?
finishedBy :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Does x finish y? Is x finished by y?
finishes :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Is x during y? Does x contain y?
contains :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Is x during y? Does x contain y?
during :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Does x start y? Is x started by y?
starts :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Does x start y? Is x started by y?
startedBy :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Does x equal y?
equals :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Is x before y? Is x after y?
precedes :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Is x before y? Is x after y?
precededBy :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Are x and y disjoint (<a>before</a>, <a>after</a>, <a>meets</a>, or
--   <a>metBy</a>)?
disjoint :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Are x and y not disjoint (concur); i.e. do they share any support?
--   This is the <a>complement</a> of <a>disjoint</a>.
notDisjoint :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Are x and y not disjoint (concur); i.e. do they share any support?
--   This is the <a>complement</a> of <a>disjoint</a>.
concur :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Is x entirely *within* (enclosed by) the endpoints of y? That is,
--   <a>during</a>, <a>starts</a>, <a>finishes</a>, or <a>equals</a>?
within :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Does x enclose y? That is, is y <a>within</a> x?
enclose :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Is x entirely *within* (enclosed by) the endpoints of y? That is,
--   <a>during</a>, <a>starts</a>, <a>finishes</a>, or <a>equals</a>?
enclosedBy :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a)

-- | Operator for composing the union of two predicates
(<|>) :: (Intervallic i0 a, Intervallic i1 a) => ComparativePredicateOf2 (i0 a) (i1 a) -> ComparativePredicateOf2 (i0 a) (i1 a) -> ComparativePredicateOf2 (i0 a) (i1 a)

-- | Forms a predicate function from the union of a set of
--   <a>IntervalRelation</a>s.
predicate :: (Intervallic i0 a, Intervallic i1 a) => Set IntervalRelation -> ComparativePredicateOf2 (i0 a) (i1 a)

-- | Compose a list of interval relations with _or_ to create a new
--   <tt><a>ComparativePredicateOf1</a> i a</tt>. For example,
--   <tt>unionPredicates [before, meets]</tt> creates a predicate function
--   determining if one interval is either before or meets another
--   interval.
unionPredicates :: [ComparativePredicateOf2 a b] -> ComparativePredicateOf2 a b

-- | The set of <tt>IntervalRelation</tt> meaning two intervals are
--   disjoint.
disjointRelations :: Set IntervalRelation

-- | The set of <tt>IntervalRelation</tt> meaning one interval is within
--   the other.
withinRelations :: Set IntervalRelation

-- | The set of <tt>IntervalRelation</tt> meaning one interval is
--   *strictly* within the other.
strictWithinRelations :: Set IntervalRelation

-- | Defines a predicate of two objects of type <tt>a</tt>.
type ComparativePredicateOf1 a = (a -> a -> Bool)

-- | Defines a predicate of two object of different types.
type ComparativePredicateOf2 a b = (a -> b -> Bool)

-- | Creates a new Interval from the <a>end</a> of an <tt>i a</tt>.
beginervalFromEnd :: (IntervalSizeable a b, Intervallic i a) => b -> i a -> Interval a

-- | Creates a new Interval from the <a>begin</a> of an <tt>i a</tt>.
endervalFromBegin :: (IntervalSizeable a b, Intervallic i a) => b -> i a -> Interval a

-- | Safely creates a new <tt>Interval</tt> with <a>moment</a> length with
--   <a>begin</a> at <tt>x</tt>
--   
--   <pre>
--   &gt;&gt;&gt; beginervalMoment (10 :: Int)
--   (10, 11)
--   </pre>
beginervalMoment :: forall a b. IntervalSizeable a b => a -> Interval a

-- | Safely creates a new <tt>Interval</tt> with <a>moment</a> length with
--   <a>end</a> at <tt>x</tt>
--   
--   <pre>
--   &gt;&gt;&gt; endervalMoment (10 :: Int)
--   (9, 10)
--   </pre>
endervalMoment :: forall a b. IntervalSizeable a b => a -> Interval a

-- | Modifies the endpoints of second argument's interval by taking the
--   difference from the first's input's <a>begin</a>. &gt;&gt;&gt;
--   shiftFromBegin (Interval ((5::Int), 6)) (Interval (10, 15)) (5, 10)
--   
--   <pre>
--   &gt;&gt;&gt; shiftFromBegin (Interval ((1::Int), 2)) (Interval (3, 15))
--   (2, 14)
--   </pre>
shiftFromBegin :: (IntervalSizeable a b, Functor i1, Intervallic i0 a) => i0 a -> i1 a -> i1 b

-- | Modifies the endpoints of second argument's interval by taking the
--   difference from the first's input's <a>end</a>. &gt;&gt;&gt;
--   shiftFromEnd (Interval ((5::Int), 6)) (Interval (10, 15)) (4, 9)
--   
--   <pre>
--   &gt;&gt;&gt; shiftFromEnd (Interval ((1::Int), 2)) (Interval (3, 15))
--   (1, 13)
--   </pre>
shiftFromEnd :: (IntervalSizeable a b, Functor i1, Intervallic i0 a) => i0 a -> i1 a -> i1 b

-- | Changes the duration of an <a>Intervallic</a> value to a moment
--   starting at the <a>begin</a> of the interval.
--   
--   <pre>
--   &gt;&gt;&gt; momentize (Interval (6, 10))
--   (6, 7)
--   </pre>
momentize :: forall i a b. (IntervalSizeable a b, Intervallic i a) => i a -> i a

-- | The <a>Set</a> of all <a>IntervalRelation</a>s.
intervalRelations :: Set IntervalRelation

-- | Compare two <tt>i a</tt> to determine their <a>IntervalRelation</a>.
--   
--   <pre>
--   &gt;&gt;&gt; relate (Interval (0::Int, 1)) (Interval (1, 2))
--   Meets
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; relate (Interval (1::Int, 2)) (Interval (0, 1))
--   MetBy
--   </pre>
relate :: (Intervallic i0 a, Intervallic i1 a) => i0 a -> i1 a -> IntervalRelation

-- | Compose two interval relations according to the rules of the algebra.
--   The rules are enumerated according to <a>this table</a>.
compose :: IntervalRelation -> IntervalRelation -> Set IntervalRelation

-- | Finds the complement of a <tt><a>Set</a> <a>IntervalRelation</a></tt>.
complement :: Set IntervalRelation -> Set IntervalRelation

-- | Find the union of two <a>Set</a>s of <a>IntervalRelation</a>s.
union :: Set IntervalRelation -> Set IntervalRelation -> Set IntervalRelation

-- | Find the intersection of two <a>Set</a>s of <a>IntervalRelation</a>s.
intersection :: Set IntervalRelation -> Set IntervalRelation -> Set IntervalRelation

-- | Find the converse of a <tt><a>Set</a> <a>IntervalRelation</a></tt>.
converse :: Set IntervalRelation -> Set IntervalRelation

-- | The <tt><a>IntervalCombinable</a></tt> typeclass provides methods for
--   (possibly) combining two <tt>i a</tt>s to form a <tt><a>Maybe</a> i
--   a</tt>, or in case of <tt>&gt;&lt;</tt>, a possibly different
--   <tt>Intervallic</tt> type.
class (Intervallic i a) => IntervalCombinable i a

-- | Maybe form a new <tt>i a</tt> by the union of two <tt>i a</tt>s that
--   <a>meets</a>.
(.+.) :: IntervalCombinable i a => i a -> i a -> Maybe (i a)

-- | If <tt>x</tt> is <a>before</a> <tt>y</tt>, then form a new <tt>Just
--   Interval a</tt> from the interval in the "gap" between <tt>x</tt> and
--   <tt>y</tt> from the <a>end</a> of <tt>x</tt> to the <a>begin</a> of
--   <tt>y</tt>. Otherwise, <a>Nothing</a>.
(><) :: IntervalCombinable i a => i a -> i a -> Maybe (i a)

-- | If <tt>x</tt> is <a>before</a> <tt>y</tt>, return <tt>f x</tt>
--   appended to <tt>f y</tt>. Otherwise, return <a>extenterval</a> of
--   <tt>x</tt> and <tt>y</tt> (wrapped in <tt>f</tt>). This is useful for
--   (left) folding over an *ordered* container of <tt>Interval</tt>s and
--   combining intervals when <tt>x</tt> is *not* <a>before</a> <tt>y</tt>.
(<+>) :: (IntervalCombinable i a, Semigroup (f (i a)), Applicative f) => i a -> i a -> f (i a)

-- | Creates a new <tt>Interval</tt> spanning the extent x and y.
--   
--   <pre>
--   &gt;&gt;&gt; extenterval (Interval (0, 1)) (Interval (9, 10))
--   (0, 10)
--   </pre>
extenterval :: Intervallic i a => i a -> i a -> Interval a

-- | The <a>IntervalSizeable</a> typeclass provides functions to determine
--   the size of an <a>Intervallic</a> type and to resize an 'Interval a'.
class (Ord a, Num b, Ord b) => IntervalSizeable a b | a -> b

-- | The smallest duration for an 'Interval a'.
moment :: forall a. IntervalSizeable a b => b

-- | Determine the duration of an <tt>'i a'</tt>.
duration :: (IntervalSizeable a b, Intervallic i a) => i a -> b

-- | Shifts an <tt>a</tt>. Most often, the <tt>b</tt> will be the same type
--   as <tt>a</tt>. But for example, if <tt>a</tt> is <a>Day</a> then
--   <tt>b</tt> could be <a>Int</a>.
add :: IntervalSizeable a b => b -> a -> a

-- | Takes the difference between two <tt>a</tt> to return a <tt>b</tt>.
diff :: IntervalSizeable a b => a -> a -> b
instance GHC.Generics.Generic (IntervalAlgebra.Core.Interval a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (IntervalAlgebra.Core.Interval a)
instance GHC.Show.Show IntervalAlgebra.Core.ParseErrorInterval
instance GHC.Classes.Eq IntervalAlgebra.Core.ParseErrorInterval
instance GHC.Enum.Enum IntervalAlgebra.Core.IntervalRelation
instance GHC.Show.Show IntervalAlgebra.Core.IntervalRelation
instance GHC.Classes.Eq IntervalAlgebra.Core.IntervalRelation
instance GHC.Classes.Ord a => IntervalAlgebra.Core.IntervalCombinable IntervalAlgebra.Core.Interval a
instance IntervalAlgebra.Core.IntervalSizeable GHC.Types.Int GHC.Types.Int
instance IntervalAlgebra.Core.IntervalSizeable GHC.Integer.Type.Integer GHC.Integer.Type.Integer
instance IntervalAlgebra.Core.IntervalSizeable Data.Time.Calendar.Days.Day GHC.Integer.Type.Integer
instance IntervalAlgebra.Core.IntervalSizeable Data.Time.Clock.Internal.UTCTime.UTCTime Data.Time.Clock.Internal.NominalDiffTime.NominalDiffTime
instance GHC.Enum.Bounded IntervalAlgebra.Core.IntervalRelation
instance GHC.Classes.Ord IntervalAlgebra.Core.IntervalRelation
instance GHC.Classes.Ord a => IntervalAlgebra.Core.Intervallic IntervalAlgebra.Core.Interval a
instance GHC.Base.Functor IntervalAlgebra.Core.Interval
instance (GHC.Show.Show a, GHC.Classes.Ord a) => GHC.Show.Show (IntervalAlgebra.Core.Interval a)
instance Data.Binary.Class.Binary a => Data.Binary.Class.Binary (IntervalAlgebra.Core.Interval a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (IntervalAlgebra.Core.Interval a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (IntervalAlgebra.Core.Interval a)
instance (GHC.Classes.Ord a, Test.QuickCheck.Arbitrary.Arbitrary a) => Test.QuickCheck.Arbitrary.Arbitrary (IntervalAlgebra.Core.Interval a)


-- | This module provides functions for creating diagrams of intervals as
--   text. For example,
--   
--   <pre>
--   &gt;&gt;&gt; let ref = bi 30 (0 :: Int)
--   
--   &gt;&gt;&gt; let ivs = [ bi 2 0, bi 5 10, bi 6 16 ]
--   
--   &gt;&gt;&gt; pretty $ simpleIntervalDiagram ref ivs
--   --                            
--             -----               
--                   ------        
--   ==============================
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Time
--   
--   &gt;&gt;&gt; let ref = bi 30 (fromGregorian 2022 5 6)
--   
--   &gt;&gt;&gt; let ivs = [ bi 2 (fromGregorian 2022 5 6), bi 5 (fromGregorian 2022 5 10)]
--   
--   &gt;&gt;&gt; pretty $ simpleIntervalDiagram ref ivs
--   --                            
--       -----                     
--   ==============================
--   </pre>
--   
--   Such diagrams are useful for documentation, examples, and learning to
--   reason with the interval algebra.
--   
--   There are two main functions available:
--   
--   <ul>
--   <li><tt><a>parseIntervalDiagram</a></tt>: exposes all available
--   options and gives the most flexibility in producing diagrams</li>
--   <li><tt><a>simpleIntervalDiagram</a></tt> produces simple diagram
--   using defaults.</li>
--   </ul>
module IntervalAlgebra.IntervalDiagram

-- | Parse inputs into a pretty printable document.
--   
--   This function provides the most flexibility in producing interval
--   diagrams.
--   
--   Here's a basic diagram that shows how to put more than one interval
--   interval on a line:
--   
--   <pre>
--   &gt;&gt;&gt; :set -XTypeApplications -XFlexibleContexts -XOverloadedStrings
--   
--   &gt;&gt;&gt; let mkIntrvl c d b = into @(IntervalText Int) (c, bi d (b :: Int))
--   
--   &gt;&gt;&gt; let x = mkIntrvl  '=' 20 0
--   
--   &gt;&gt;&gt; let l1 = [ mkIntrvl '-' 1 4 ]
--   
--   &gt;&gt;&gt; let l2 = [ mkIntrvl '*' 3 5, mkIntrvl '*' 5 10, mkIntrvl 'x' 1 17 ]
--   
--   &gt;&gt;&gt; let l3 = [ mkIntrvl '#' 2 18]
--   
--   &gt;&gt;&gt; pretty $ parseIntervalDiagram defaultIntervalDiagramOptions  [] (Just Bottom) x [ (l1, []), (l2, []), (l3, []) ]
--       -               
--        ***  *****  x  
--                     ##
--   ====================
--   </pre>
--   
--   We can put the axis on the top:
--   
--   <pre>
--   &gt;&gt;&gt; pretty $ parseIntervalDiagram defaultIntervalDiagramOptions [] (Just Top) x [ (l1, []), (l2, []), (l3, []) ]
--   ====================
--       -               
--        ***  *****  x  
--                     ##
--   </pre>
--   
--   We can annotate the axis:
--   
--   <pre>
--   &gt;&gt;&gt; pretty $ parseIntervalDiagram defaultIntervalDiagramOptions [(5, 'a')] (Just Bottom) x [ (l1, []), (l2, []), (l3, []) ]
--       -               
--        ***  *****  x  
--                     ##
--   ====================
--        |
--        a
--   </pre>
--   
--   We can also annotate each line with labels:
--   
--   <pre>
--   &gt;&gt;&gt; pretty $ parseIntervalDiagram defaultIntervalDiagramOptions [] (Just Bottom) x [ (l1, ["line1"]), (l2, ["line2a", "line2b"]), (l3, ["line3"])  ]
--       -                &lt;- [line1]
--        ***  *****  x   &lt;- [line2a, line2b]
--                     ## &lt;- [line3]
--   ====================
--   </pre>
--   
--   The parser tries to check that the data can be printed. For example,
--   the default <tt><a>LayoutOptions</a></tt> is 80 characters. Providing
--   an reference interval wider than 80 characters results in an error.
--   
--   <pre>
--   &gt;&gt;&gt; let x = mkIntrvl '=' 100 5
--   
--   &gt;&gt;&gt; let ivs = [ mkIntrvl '-' 1 1 ]
--   
--   &gt;&gt;&gt; parseIntervalDiagram defaultIntervalDiagramOptions [] Nothing x [ (ivs, []) ]
--   Left AxisWiderThanAvailable
--   </pre>
--   
--   See <a>IntervalDiagramParseError</a> for all the cases handled.
parseIntervalDiagram :: (Ord a, IntervalSizeable a b, Enum b) => IntervalDiagramOptions -> [(Int, Char)] -> Maybe AxisPlacement -> IntervalText a -> [([IntervalText a], [Text])] -> Either IntervalDiagramParseError (IntervalDiagram a)

-- | Given a reference interval and a list of intervals, produces an
--   <a>IntervalDiagram</a> with one line per interval, using the
--   <a>defaultIntervalDiagramOptions</a>.
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Maybe (fromMaybe)
--   
--   &gt;&gt;&gt; import IntervalAlgebra.IntervalUtilities (gapsWithin)
--   
--   &gt;&gt;&gt; pretty $ simpleIntervalDiagram (bi 10 (0 :: Int)) (fmap (bi 1) [0..9])
--   -
--    -
--     -
--      -
--       -
--        -
--         -
--          -
--           -
--            -
--   ==========
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let ref = bi 30 (0 :: Int)
--   
--   &gt;&gt;&gt; let ivs = [ bi 2 0, bi 5 10, bi 6 16 ]
--   
--   &gt;&gt;&gt; pretty $ simpleIntervalDiagram ref ivs
--   --
--             -----
--                   ------
--   ==============================
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; pretty $ simpleIntervalDiagram ref (fromMaybe [] (gapsWithin ref ivs))
--     --------
--                  -
--                         --------
--   ==============================
--   </pre>
simpleIntervalDiagram :: (Ord a, IntervalSizeable a b, Intervallic i a, Enum b) => i a -> [i a] -> Either IntervalDiagramParseError (IntervalDiagram a)

-- | A record containing options for printing an
--   <tt><a>IntervalDiagram</a></tt>.
data IntervalDiagramOptions
MkIntervalDiagramOptions :: LayoutOptions -> Int -> IntervalDiagramOptions

-- | See <a>LayoutOptions</a>
[layout] :: IntervalDiagramOptions -> LayoutOptions

-- | Number of spaces to pad the left of the diagram by. Must be greater
--   than or equal to <tt>0</tt>.
[leftPadding] :: IntervalDiagramOptions -> Int

-- | Default <a>IntervalDiagramOptions</a> options
defaultIntervalDiagramOptions :: IntervalDiagramOptions

-- | A type representing options of where to place the axis in a printed
--   diagram.
data AxisPlacement

-- | Print the axis at the top of the diagram
Top :: AxisPlacement

-- | Print the axis at the bottom of the diagram
Bottom :: AxisPlacement

-- | <tt>IntervalText</tt> is an internal type which contains an
--   <tt>Interval a</tt> and the <tt>Char</tt> used to print the interval
--   in a diagram.
--   
--   The <tt>Interval a</tt> type needs to be an instance of
--   <tt>IntervalSizeable a b</tt>; Moreover, the type <tt>b</tt> should be
--   castable to <tt>Int</tt>, using its <tt><a>From</a> b Int</tt>
--   instance.
--   
--   <pre>
--   &gt;&gt;&gt; import Prettyprinter (pretty)
--   
--   &gt;&gt;&gt; import IntervalAlgebra (beginerval)
--   
--   &gt;&gt;&gt; pretty $ MkIntervalText '-' (beginerval 5 (0::Int))
--   -----
--   
--   &gt;&gt;&gt; pretty $ MkIntervalText '*' (beginerval 10 (0::Int))
--   **********
--   </pre>
data IntervalText a

-- | Type containing the data needed to pretty print an interval document.
data IntervalDiagram a

-- | A type representing errors that may occur when a list of
--   <tt>IntervalText</tt> is parsed into a <tt>IntervalTextLine</tt>.
data IntervalTextLineParseError

-- | The inputs contains concurring intervals. All inputs should be
--   <tt><a>disjoint</a></tt>.
ConcurringIntervals :: IntervalTextLineParseError

-- | The inputs are not sorted.
UnsortedIntervals :: IntervalTextLineParseError

-- | At least one of the inputs has a <tt><a>begin</a></tt> less than zero.
BeginsLessThanZero :: IntervalTextLineParseError

-- | A type representing errors that can occur when parsing an axis.
data AxisParseError

-- | Indicates that the position of one ore more axis labels is outside the
--   reference interval
LabelsBeyondReference :: AxisParseError

-- | Indicates that multiple labels have been put at the same position
MultipleLabelAtSamePosition :: AxisParseError

-- | A type representing the types of invalid
--   <tt><a>IntervalDiagramOptions</a></tt>.
data IntervalDiagramOptionsError

-- | Indicates that <tt><a>PageWidth</a></tt> is <tt>Unbounded</tt>, which
--   isn't allowed for an IntervalDiagram.
UnboundedPageWidth :: IntervalDiagramOptionsError

-- | Indicates that the left padding in the option is &lt; 0.
LeftPaddingLessThan0 :: IntervalDiagramOptionsError

-- | Type representing errors that may occur when parsing inputs into an
--   <tt><a>IntervalDiagram</a></tt>.
--   
--   Not every possible state of a "bad" diagram is currently captured by
--   <a>parseIntervalDiagram</a>. In particular, line labels can be a
--   source of problems. The labels accept arbitrary <tt>Text</tt>. Newline
--   characters in a label would, for example, throw things off. Labels
--   that extend beyond the <tt><a>pageWidth</a></tt> will also cause
--   problems.
data IntervalDiagramParseError

-- | Indicates that one or more of the input intervals extend beyond the
--   axis.
IntervalsExtendBeyondAxis :: IntervalDiagramParseError

-- | Indicates that the reference axis is longer than the
--   <tt><a>PageWidth</a></tt> given in the
--   <tt><a>IntervalDiagramOptions</a></tt>.
AxisWiderThanAvailable :: IntervalDiagramParseError

-- | Indicates that left padding is &gt;0 and no axis is printed. This is
--   considered an error because it be impossible to know the <a>begin</a>
--   values of intervals in a printed <tt>IntervalDiagram</tt> that has
--   been padded and has no axis.
PaddingWithNoAxis :: IntervalDiagramParseError

-- | Indicates that an error occurring when checking the document options.
OptionsError :: IntervalDiagramOptionsError -> IntervalDiagramParseError

-- | Indicates something is wrong with the <tt>Axis</tt>.
AxisError :: AxisParseError -> IntervalDiagramParseError

-- | Indicates that at least one error occurred when parsing the interval
--   lines.
IntervalLineError :: IntervalTextLineParseError -> IntervalDiagramParseError
instance (GHC.Show.Show a, GHC.Classes.Ord a) => GHC.Show.Show (IntervalAlgebra.IntervalDiagram.IntervalText a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (IntervalAlgebra.IntervalDiagram.IntervalText a)
instance (GHC.Show.Show a, GHC.Classes.Ord a) => GHC.Show.Show (IntervalAlgebra.IntervalDiagram.IntervalTextLine a)
instance GHC.Classes.Ord IntervalAlgebra.IntervalDiagram.IntervalTextLineParseError
instance GHC.Show.Show IntervalAlgebra.IntervalDiagram.IntervalTextLineParseError
instance GHC.Classes.Eq IntervalAlgebra.IntervalDiagram.IntervalTextLineParseError
instance GHC.Show.Show IntervalAlgebra.IntervalDiagram.AxisPlacement
instance GHC.Classes.Eq IntervalAlgebra.IntervalDiagram.AxisPlacement
instance GHC.Show.Show IntervalAlgebra.IntervalDiagram.AxisLabels
instance GHC.Classes.Eq IntervalAlgebra.IntervalDiagram.AxisLabels
instance GHC.Show.Show IntervalAlgebra.IntervalDiagram.AxisConfig
instance GHC.Classes.Eq IntervalAlgebra.IntervalDiagram.AxisConfig
instance GHC.Show.Show IntervalAlgebra.IntervalDiagram.Axis
instance GHC.Classes.Eq IntervalAlgebra.IntervalDiagram.Axis
instance GHC.Show.Show IntervalAlgebra.IntervalDiagram.AxisParseError
instance GHC.Classes.Eq IntervalAlgebra.IntervalDiagram.AxisParseError
instance GHC.Show.Show IntervalAlgebra.IntervalDiagram.IntervalDiagramOptions
instance GHC.Classes.Eq IntervalAlgebra.IntervalDiagram.IntervalDiagramOptions
instance GHC.Show.Show IntervalAlgebra.IntervalDiagram.IntervalDiagramOptionsError
instance GHC.Classes.Eq IntervalAlgebra.IntervalDiagram.IntervalDiagramOptionsError
instance (GHC.Show.Show a, GHC.Classes.Ord a) => GHC.Show.Show (IntervalAlgebra.IntervalDiagram.IntervalDiagram a)
instance GHC.Show.Show IntervalAlgebra.IntervalDiagram.IntervalDiagramParseError
instance GHC.Classes.Eq IntervalAlgebra.IntervalDiagram.IntervalDiagramParseError
instance IntervalAlgebra.Core.IntervalSizeable a b => Prettyprinter.Internal.Pretty (Data.Either.Either IntervalAlgebra.IntervalDiagram.IntervalDiagramParseError (IntervalAlgebra.IntervalDiagram.IntervalDiagram a))
instance IntervalAlgebra.Core.IntervalSizeable a b => Prettyprinter.Internal.Pretty (IntervalAlgebra.IntervalDiagram.IntervalDiagram a)
instance Prettyprinter.Internal.Pretty (Data.Either.Either IntervalAlgebra.IntervalDiagram.AxisParseError IntervalAlgebra.IntervalDiagram.Axis)
instance Prettyprinter.Internal.Pretty IntervalAlgebra.IntervalDiagram.Axis
instance Prettyprinter.Internal.Pretty (Data.Either.Either IntervalAlgebra.IntervalDiagram.IntervalTextLineParseError (IntervalAlgebra.IntervalDiagram.IntervalTextLine GHC.Types.Int))
instance Prettyprinter.Internal.Pretty (IntervalAlgebra.IntervalDiagram.IntervalTextLine GHC.Types.Int)
instance GHC.Classes.Ord a => IntervalAlgebra.Core.Intervallic IntervalAlgebra.IntervalDiagram.IntervalText a
instance GHC.Base.Functor IntervalAlgebra.IntervalDiagram.IntervalText
instance (GHC.Enum.Enum b, IntervalAlgebra.Core.IntervalSizeable a b) => Prettyprinter.Internal.Pretty (IntervalAlgebra.IntervalDiagram.IntervalText a)
instance Witch.From.From (GHC.Types.Char, IntervalAlgebra.Core.Interval a) (IntervalAlgebra.IntervalDiagram.IntervalText a)
instance Witch.From.From (IntervalAlgebra.IntervalDiagram.IntervalText a) GHC.Types.Char
instance Witch.From.From (IntervalAlgebra.IntervalDiagram.IntervalText a) (IntervalAlgebra.Core.Interval a)


module IntervalAlgebra.PairedInterval

-- | An <tt>Interval a</tt> paired with some other data of type <tt>b</tt>.
data PairedInterval b a

-- | Empty is used to trivially lift an <tt>Interval a</tt> into a
--   <tt>PairedInterval</tt>.
data Empty
Empty :: Empty

-- | Make a paired interval.
makePairedInterval :: b -> Interval a -> PairedInterval b a

-- | Gets the data (i.e. non-interval) part of a <tt>PairedInterval</tt>.
getPairData :: PairedInterval b a -> b

-- | Gets the intervals from a list of paired intervals.
intervals :: (Ord a, Functor f) => f (PairedInterval b a) -> f (Interval a)

-- | Tests for equality of the data in a <tt>PairedInterval</tt>.
equalPairData :: Eq b => ComparativePredicateOf1 (PairedInterval b a)

-- | Lifts an <tt>Interval a</tt> into a <tt>PairedInterval Empty a</tt>,
--   where <tt>Empty</tt> is a trivial type that contains no data.
toTrivialPair :: Interval a -> PairedInterval Empty a

-- | Lifts a <tt>Functor</tt> containing <tt>Interval a</tt>(s) into a
--   <tt>Functor</tt> containing <tt>PairedInterval Empty a</tt>(s).
trivialize :: Functor f => f (Interval a) -> f (PairedInterval Empty a)
instance GHC.Generics.Generic (IntervalAlgebra.PairedInterval.PairedInterval b a)
instance (GHC.Classes.Eq a, GHC.Classes.Eq b) => GHC.Classes.Eq (IntervalAlgebra.PairedInterval.PairedInterval b a)
instance GHC.Show.Show IntervalAlgebra.PairedInterval.Empty
instance GHC.Classes.Ord IntervalAlgebra.PairedInterval.Empty
instance GHC.Classes.Eq IntervalAlgebra.PairedInterval.Empty
instance GHC.Base.Semigroup IntervalAlgebra.PairedInterval.Empty
instance GHC.Base.Monoid IntervalAlgebra.PairedInterval.Empty
instance GHC.Classes.Ord a => IntervalAlgebra.Core.Intervallic (IntervalAlgebra.PairedInterval.PairedInterval b) a
instance GHC.Base.Functor (IntervalAlgebra.PairedInterval.PairedInterval b)
instance Data.Bifunctor.Bifunctor IntervalAlgebra.PairedInterval.PairedInterval
instance (Control.DeepSeq.NFData a, Control.DeepSeq.NFData b) => Control.DeepSeq.NFData (IntervalAlgebra.PairedInterval.PairedInterval b a)
instance (Data.Binary.Class.Binary a, Data.Binary.Class.Binary b) => Data.Binary.Class.Binary (IntervalAlgebra.PairedInterval.PairedInterval b a)
instance (GHC.Classes.Eq a, GHC.Classes.Eq b, GHC.Classes.Ord a) => GHC.Classes.Ord (IntervalAlgebra.PairedInterval.PairedInterval b a)
instance (GHC.Show.Show b, GHC.Show.Show a, GHC.Classes.Ord a) => GHC.Show.Show (IntervalAlgebra.PairedInterval.PairedInterval b a)
instance (GHC.Classes.Ord a, GHC.Classes.Eq b, GHC.Base.Monoid b) => IntervalAlgebra.Core.IntervalCombinable (IntervalAlgebra.PairedInterval.PairedInterval b) a
instance (Test.QuickCheck.Arbitrary.Arbitrary b, GHC.Classes.Ord a, Test.QuickCheck.Arbitrary.Arbitrary a) => Test.QuickCheck.Arbitrary.Arbitrary (IntervalAlgebra.PairedInterval.PairedInterval b a)


module IntervalAlgebra.IntervalUtilities

-- | Returns a container of intervals where any intervals that meet or
--   share support are combined into one interval. *To work properly, the
--   input should be sorted*. See <a>combineIntervalsL</a> for a version
--   that works only on lists.
--   
--   <pre>
--   &gt;&gt;&gt; combineIntervals [iv 10 0, iv 5 2, iv 2 10, iv 2 13]
--   [(0, 12),(13, 15)]
--   </pre>
combineIntervals :: (Applicative f, Ord a, Intervallic i a, Monoid (f (Interval a)), Foldable f) => f (i a) -> f (Interval a)

-- | Returns a list of intervals where any intervals that meet or share
--   support are combined into one interval. *To work properly, the input
--   list should be sorted*.
--   
--   <pre>
--   &gt;&gt;&gt; combineIntervalsL [iv 10 0, iv 5 2, iv 2 10, iv 2 13]
--   [(0, 12),(13, 15)]
--   </pre>
combineIntervalsL :: Intervallic i a => [i a] -> [Interval a]

-- | Maybe form an <tt>Interval a</tt> from <tt>Control.Foldl t =&gt; t
--   (Interval a)</tt> spanning the range of all intervals in the list,
--   i.e. whose <tt>begin</tt> is the minimum of <tt>begin</tt> across
--   intervals in the list and whose <tt>end</tt> is the maximum of
--   <tt>end</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; rangeInterval [beginerval 0 0, beginerval 0 (-1)]
--   Just (-1, 1)
--   
--   &gt;&gt;&gt; rangeInterval ([] :: [Interval Int])
--   Nothing
--   
--   &gt;&gt;&gt; rangeInterval (Just (beginerval 0 0))
--   Just (0, 1)
--   </pre>
rangeInterval :: (Ord a, Foldable t) => t (Interval a) -> Maybe (Interval a)

-- | Returns a <tt>Maybe</tt> container of intervals consisting of the gaps
--   between intervals in the input. *To work properly, the input should be
--   sorted*. See <a>gapsL</a> for a version that always returns a list.
--   
--   <pre>
--   &gt;&gt;&gt; gaps [iv 4 1, iv 4 8, iv 3 11]
--   Nothing
--   </pre>
gaps :: (IntervalCombinable i a, Traversable f, Monoid (f (Maybe (Interval a))), Applicative f) => f (i a) -> Maybe (f (Interval a))

-- | Returns a (possibly empty) list of intervals consisting of the gaps
--   between intervals in the input container. *To work properly, the input
--   should be sorted*. This version outputs a list. See <a>gaps</a> for a
--   version that lifts the result to same input structure <tt>f</tt>.
gapsL :: (IntervalCombinable i a, Applicative f, Monoid (f (Maybe (Interval a))), Traversable f) => f (i a) -> [Interval a]

-- | Applies <a>gaps</a> to all the non-disjoint intervals in <tt>x</tt>
--   that are *not* disjoint from <tt>i</tt>. Intervals that
--   <a>overlaps</a> or are <a>overlappedBy</a> <tt>i</tt> are
--   <a>clip</a>ped to <tt>i</tt>, so that all the intervals are
--   <a>within</a> <tt>i</tt>. If all of the input intervals are disjoint
--   from the focal interval or if the input is empty, then <a>Nothing</a>
--   is returned. When there are no gaps among the concurring intervals,
--   then `Just mempty` (e.g. `Just []`) is returned.
--   
--   <pre>
--   &gt;&gt;&gt; gapsWithin (iv 9 1) [iv 5 0, iv 2 7, iv 3 12]
--   Just [(5, 7),(9, 10)]
--   </pre>
gapsWithin :: (Applicative f, Witherable f, Monoid (f (Interval a)), Monoid (f (Maybe (Interval a))), IntervalSizeable a b, Intervallic i0 a, IntervalCombinable i1 a) => i0 a -> f (i1 a) -> Maybe (f (Interval a))

-- | Folds over a list of Paired Intervals and in the case that the
--   <a>getPairData</a> is equal between two sequential meeting intervals,
--   these two intervals are combined into one. This function is "safe" in
--   the sense that if the input is invalid and contains any sequential
--   pairs of intervals with an <tt>IntervalRelation</tt>, other than
--   <a>Meets</a>, then the function returns an empty list.
foldMeetingSafe :: (Eq b, Ord a, Show a) => [PairedInterval b a] -> [PairedInterval b a]

-- | Convert an ordered sequence of <tt>PairedInterval b a</tt>. that may
--   have any interval relation (<a>before</a>, <a>starts</a>, etc) into a
--   sequence of sequentially meeting <tt>PairedInterval b a</tt>. That is,
--   a sequence where one the end of one interval meets the beginning of
--   the subsequent event. The <a>getPairData</a> of the input
--   <tt>PairedIntervals</tt> are combined using the Monoid <a>&lt;&gt;</a>
--   function, hence the pair data must be a <a>Monoid</a> instance.
formMeetingSequence :: (Eq b, Show a, Monoid b, IntervalSizeable a c) => [PairedInterval b a] -> [PairedInterval b a]

-- | Given a predicate combinator, a predicate, and list of intervals,
--   returns the input unchanged if the predicate combinator is
--   <tt>True</tt>. Otherwise, returns an empty list. See
--   <a>nothingIfAny</a> and <a>nothingIfNone</a> for examples.
nothingIf :: (Monoid (f (i a)), Filterable f) => ((i a -> Bool) -> f (i a) -> Bool) -> (i a -> Bool) -> f (i a) -> Maybe (f (i a))

-- | Returns the <a>Nothing</a> if *none* of the element of input satisfy
--   the predicate condition.
--   
--   For example, the following returns <a>Nothing</a> because none of the
--   intervals in the input list <a>starts</a> (3, 5).
--   
--   <pre>
--   &gt;&gt;&gt; nothingIfNone (starts (iv 2 3)) [iv 1 3, iv 1 5]
--   Nothing
--   </pre>
--   
--   In the following, (3, 5) <a>starts</a> (3, 6), so <a>Just</a> the
--   input is returned.
--   
--   <pre>
--   &gt;&gt;&gt; nothingIfNone (starts (iv 2 3)) [iv 3 3, iv 1 5]
--   Just [(3, 6),(5, 6)]
--   </pre>
nothingIfNone :: (Monoid (f (i a)), Foldable f, Filterable f) => (i a -> Bool) -> f (i a) -> Maybe (f (i a))

-- | Returns <a>Nothing</a> if *any* of the element of input satisfy the
--   predicate condition.
--   
--   <pre>
--   &gt;&gt;&gt; nothingIfAny (startedBy (iv 2 3)) [iv 3 3, iv 1 5]
--   Just [(3, 6),(5, 6)]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; nothingIfAny (starts (iv 2 3)) [iv 3 3, iv 1 5]
--   Nothing
--   </pre>
nothingIfAny :: (Monoid (f (i a)), Foldable f, Filterable f) => (i a -> Bool) -> f (i a) -> Maybe (f (i a))

-- | Returns <a>Nothing</a> if *all* of the element of input satisfy the
--   predicate condition.
--   
--   <pre>
--   &gt;&gt;&gt; nothingIfAll (starts (iv 2 3)) [iv 3 3, iv 4 3]
--   Nothing
--   </pre>
nothingIfAll :: (Monoid (f (i a)), Foldable f, Filterable f) => (i a -> Bool) -> f (i a) -> Maybe (f (i a))

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterBefore :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterMeets :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterOverlaps :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterFinishedBy :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterContains :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterStarts :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterEquals :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterStartedBy :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterDuring :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterFinishes :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterOverlappedBy :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterMetBy :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterAfter :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterDisjoint :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterNotDisjoint :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterConcur :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterWithin :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterEnclose :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Filter <a>Filterable</a> containers of one <tt><a>Intervallic</a></tt>
--   type based by comparing to a (potentially different)
--   <a>Intervallic</a> type using the corresponding interval predicate
--   function.
filterEnclosedBy :: (Filterable f, Intervallic i0 a, Intervallic i1 a) => i0 a -> f (i1 a) -> f (i1 a)

-- | Creates a new <tt>Interval</tt> of a provided lookback duration ending
--   at the <a>begin</a> of the input interval.
--   
--   <pre>
--   &gt;&gt;&gt; lookback 4 (beginerval 10 (1 :: Int))
--   (-3, 1)
--   </pre>
lookback :: (Intervallic i a, IntervalSizeable a b) => b -> i a -> Interval a

-- | Creates a new <tt>Interval</tt> of a provided lookahead duration
--   beginning at the <a>end</a> of the input interval.
--   
--   <pre>
--   &gt;&gt;&gt; lookahead 4 (beginerval 1 (1 :: Int))
--   (2, 6)
--   </pre>
lookahead :: (Intervallic i a, IntervalSizeable a b) => b -> i a -> Interval a

-- | Create a predicate function that checks whether within a provided
--   spanning interval, are there (e.g. any, all) gaps of (e.g.
--   <a>&lt;=,</a>=, &gt;) a specified duration among the input intervals?
makeGapsWithinPredicate :: (Monoid (t (Interval a)), Monoid (t (Maybe (Interval a))), Applicative t, Witherable t, IntervalSizeable a b, Intervallic i0 a, IntervalCombinable i1 a) => ((b -> Bool) -> t b -> Bool) -> (b -> b -> Bool) -> b -> i0 a -> t (i1 a) -> Bool

-- | Gets the durations of gaps (via 'IntervalAlgebra.(&gt;&lt;)') between
--   all pairs of the input.
pairGaps :: (Intervallic i a, IntervalSizeable a b, IntervalCombinable i a) => [i a] -> [Maybe b]

-- | Within a provided spanning interval, are there any gaps of at least
--   the specified duration among the input intervals?
anyGapsWithinAtLeastDuration :: (IntervalSizeable a b, Intervallic i0 a, IntervalCombinable i1 a, Monoid (t (Interval a)), Monoid (t (Maybe (Interval a))), Applicative t, Witherable t) => b -> i0 a -> t (i1 a) -> Bool

-- | Within a provided spanning interval, are all gaps less than the
--   specified duration among the input intervals?
--   
--   <pre>
--   &gt;&gt;&gt; allGapsWithinLessThanDuration 30 (beginerval 100 (0::Int)) [beginerval 5 (-1), beginerval 99 10]
--   True
--   </pre>
allGapsWithinLessThanDuration :: (IntervalSizeable a b, Intervallic i0 a, IntervalCombinable i1 a, Monoid (t (Interval a)), Monoid (t (Maybe (Interval a))), Applicative t, Witherable t) => b -> i0 a -> t (i1 a) -> Bool

-- | A generic form of <a>relations</a> which can output any
--   <a>Applicative</a> and <a>Monoid</a> structure.
--   
--   <pre>
--   &gt;&gt;&gt; (relations [iv 1 0,iv 1 1]) :: [IntervalRelation]
--   [Meets]
--   </pre>
relations :: (Foldable f, Applicative m, Intervallic i a, Monoid (m IntervalRelation)) => f (i a) -> m IntervalRelation

-- | Returns a list of the <a>IntervalRelation</a> between each consecutive
--   pair of intervals. This is just a specialized <a>relations</a> which
--   returns a list.
--   
--   <pre>
--   &gt;&gt;&gt; relationsL [iv 1 0, iv 1 1]
--   [Meets]
--   </pre>
relationsL :: (Foldable f, Intervallic i a) => f (i a) -> [IntervalRelation]

-- | Forms a <a>Just</a> new interval from the intersection of two
--   intervals, provided the intervals are not disjoint.
--   
--   <pre>
--   &gt;&gt;&gt; intersect (iv 5 0) (iv 2 3)
--   Just (3, 5)
--   </pre>
intersect :: (Intervallic i a, IntervalSizeable a b) => i a -> i a -> Maybe (Interval a)

-- | In the case that x y are not disjoint, clips y to the extent of x.
--   
--   <pre>
--   &gt;&gt;&gt; clip (iv 5 0) (iv 3 3)
--   Just (3, 5)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; clip (iv 3 0) (iv 2 4)
--   Nothing
--   </pre>
clip :: (Intervallic i0 a, Intervallic i1 a, IntervalSizeable a b) => i0 a -> i1 a -> Maybe (Interval a)

-- | Returns the <a>duration</a> of each 'Intervallic i a' in the
--   <a>Functor</a> <tt>f</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; durations [iv 9 1, iv 10 2, iv 1 5]
--   [9,10,1]
--   </pre>
durations :: (Functor f, Intervallic i a, IntervalSizeable a b) => f (i a) -> f b
instance GHC.Show.Show a => GHC.Show.Show (IntervalAlgebra.IntervalUtilities.Meeting a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (IntervalAlgebra.IntervalUtilities.Meeting a)
instance GHC.Classes.Ord a => GHC.Base.Semigroup (IntervalAlgebra.IntervalUtilities.Box (IntervalAlgebra.Core.Interval a))


-- | The <tt>IntervalAlgebra</tt> module provides data types and related
--   classes for the interval-based temporal logic described in <a>Allen
--   (1983)</a> and axiomatized in <a>Allen and Hayes (1987)</a>. A good
--   primer on Allen's algebra can be <a>found here</a>.
--   
--   This main module reexports <tt>IntervalAlgebra.Core</tt>,
--   <tt>IntervalAlgebra.IntervalUtilities</tt>, and
--   <tt>IntervalAlgebra.PairedInterval</tt>, which is probably more than
--   enough to get going for most cases.
module IntervalAlgebra


module IntervalAlgebra.Arbitrary

-- | Conditional generation of intervals relative to a reference. If the
--   reference <tt>iv</tt> is of <a>moment</a> duration, it is not possible
--   to generate intervals from the strict enclose relations StartedBy,
--   Contains, FinishedBy. If <tt>iv</tt> and <tt>rs</tt> are such that no
--   possible relations can be generated, this function returns
--   <a>Nothing</a>. Otherwise, it returns <a>Just</a> an interval that
--   satisfies at least one of the possible relations in <tt>rs</tt>
--   relative to <tt>iv</tt>.
--   
--   <pre>
--   &gt; import Test.QuickCheck (generate)
--   &gt; import Data.Set (fromList)
--   &gt; isJust $ generate $ arbitraryWithRelation (beginerval 10 (0::Int)) (fromList [Before])
--   Just (20, 22)
--   &gt; generate $ arbitraryWithRelation (beginerval 1 (0::Int)) (fromList [StartedBy])
--   Nothing
--   &gt; generate $ arbitraryWithRelation (beginerval 1 (0::Int)) (fromList [StartedBy, Before])
--   Just (4, 13)
--   </pre>
arbitraryWithRelation :: forall i a b. (IntervalSizeable a b, Intervallic i a, Arbitrary (i a)) => i a -> Set IntervalRelation -> Gen (Maybe (i a))
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Time.Calendar.Days.Day
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Time.Clock.Internal.NominalDiffTime.NominalDiffTime
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Time.Clock.Internal.DiffTime.DiffTime
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Time.Clock.Internal.UTCTime.UTCTime


-- | This module exports a single typeclass <tt>IntervalAxioms</tt> which
--   contains property-based tests for the axioms in section 1 of <a>Allen
--   and Hayes (1987)</a>. The notation below is that of the original
--   paper.
--   
--   This module is useful if creating a new instance of interval types
--   that you want to test.
module IntervalAlgebra.Axioms

-- | <h1>"An Axiomatization of Interval Time".</h1>
class (IntervalSizeable a b) => IntervalAxioms a b

-- | Smart constructor of <a>M1set</a>.
m1set :: (IntervalAxioms a b, IntervalSizeable a b) => Interval a -> b -> b -> b -> M1set a

-- | <h2>Axiom M1</h2>
--   
--   The first axiom of Allen and Hayes (1987) states that if "two periods
--   both meet a third, thn any period met by one must also be met by the
--   other." That is:
--   
--   &lt;math&gt;
prop_IAaxiomM1 :: (IntervalAxioms a b, Ord a) => M1set a -> Property

-- | Smart constructor of <a>M2set</a>.
m2set :: (IntervalAxioms a b, IntervalSizeable a b) => Interval a -> Interval a -> b -> b -> M2set a

-- | <h2>Axiom M2</h2>
--   
--   If period i meets period j and period k meets l, then exactly one of
--   the following holds:
--   
--   1) i meets l; 2) there is an m such that i meets m and m meets l; 3)
--   there is an n such that k meets n and n meets j.
--   
--   That is,
--   
--   &lt;math&gt;
prop_IAaxiomM2 :: (IntervalAxioms a b, IntervalSizeable a b, Show a) => M2set a -> Property

-- | <h2>Axiom ML1</h2>
--   
--   An interval cannot meet itself.
--   
--   &lt;math&gt;
prop_IAaxiomML1 :: (IntervalAxioms a b, Ord a) => Interval a -> Property

-- | <h2>Axiom ML2</h2>
--   
--   If i meets j then j does not meet i.
--   
--   &lt;math&gt;
prop_IAaxiomML2 :: (IntervalAxioms a b, Ord a) => M2set a -> Property

-- | <h2>Axiom M3</h2>
--   
--   Time does not start or stop:
--   
--   &lt;math&gt;
prop_IAaxiomM3 :: (IntervalAxioms a b, IntervalSizeable a b) => b -> Interval a -> Property

-- | ML3 says that For all i, there does not exist m such that i meets m
--   and m meet i. Not testing that this axiom holds, as I'm not sure how I
--   would test the lack of existence easily.
--   
--   <h2>Axiom M4</h2>
--   
--   If two meets are separated by intervals, then this sequence is a
--   longer interval.
--   
--   &lt;math&gt;
prop_IAaxiomM4 :: (IntervalAxioms a b, IntervalSizeable a b) => b -> M2set a -> Property

-- | Smart constructor of <a>M5set</a>.
m5set :: (IntervalAxioms a b, IntervalSizeable a b) => Interval a -> b -> b -> M5set a

-- | <h2>Axiom M5</h2>
--   
--   There is only one time period between any two meeting places.
--   
--   &lt;math&gt;
prop_IAaxiomM5 :: (IntervalAxioms a b, IntervalSizeable a b) => M5set a -> Property

-- | <h2>Axiom M4.1</h2>
--   
--   Ordered unions:
--   
--   &lt;math&gt;
prop_IAaxiomM4_1 :: (IntervalAxioms a b, IntervalSizeable a b) => b -> M2set a -> Property

-- | A set used for testing M1 defined so that the M1 condition is true.
data M1set a
M1set :: Interval a -> Interval a -> Interval a -> Interval a -> M1set a
[m11] :: M1set a -> Interval a
[m12] :: M1set a -> Interval a
[m13] :: M1set a -> Interval a
[m14] :: M1set a -> Interval a

-- | A set used for testing M2 defined so that the M2 condition is true.
data M2set a
M2set :: Interval a -> Interval a -> Interval a -> Interval a -> M2set a
[m21] :: M2set a -> Interval a
[m22] :: M2set a -> Interval a
[m23] :: M2set a -> Interval a
[m24] :: M2set a -> Interval a

-- | A set used for testing M5.
data M5set a
M5set :: Interval a -> Interval a -> M5set a
[m51] :: M5set a -> Interval a
[m52] :: M5set a -> Interval a
instance (GHC.Show.Show a, GHC.Classes.Ord a) => GHC.Show.Show (IntervalAlgebra.Axioms.M1set a)
instance (GHC.Show.Show a, GHC.Classes.Ord a) => GHC.Show.Show (IntervalAlgebra.Axioms.M2set a)
instance (GHC.Show.Show a, GHC.Classes.Ord a) => GHC.Show.Show (IntervalAlgebra.Axioms.M5set a)
instance Test.QuickCheck.Arbitrary.Arbitrary (IntervalAlgebra.Axioms.M1set GHC.Types.Int)
instance Test.QuickCheck.Arbitrary.Arbitrary (IntervalAlgebra.Axioms.M1set Data.Time.Calendar.Days.Day)
instance Test.QuickCheck.Arbitrary.Arbitrary (IntervalAlgebra.Axioms.M1set Data.Time.Clock.Internal.UTCTime.UTCTime)
instance Test.QuickCheck.Arbitrary.Arbitrary (IntervalAlgebra.Axioms.M2set GHC.Types.Int)
instance Test.QuickCheck.Arbitrary.Arbitrary (IntervalAlgebra.Axioms.M2set Data.Time.Calendar.Days.Day)
instance Test.QuickCheck.Arbitrary.Arbitrary (IntervalAlgebra.Axioms.M2set Data.Time.Clock.Internal.UTCTime.UTCTime)
instance Test.QuickCheck.Arbitrary.Arbitrary (IntervalAlgebra.Axioms.M5set GHC.Types.Int)
instance Test.QuickCheck.Arbitrary.Arbitrary (IntervalAlgebra.Axioms.M5set Data.Time.Calendar.Days.Day)
instance Test.QuickCheck.Arbitrary.Arbitrary (IntervalAlgebra.Axioms.M5set Data.Time.Clock.Internal.UTCTime.UTCTime)
instance IntervalAlgebra.Axioms.IntervalAxioms GHC.Types.Int GHC.Types.Int
instance IntervalAlgebra.Axioms.IntervalAxioms Data.Time.Calendar.Days.Day GHC.Integer.Type.Integer
instance IntervalAlgebra.Axioms.IntervalAxioms Data.Time.Clock.Internal.UTCTime.UTCTime Data.Time.Clock.Internal.NominalDiffTime.NominalDiffTime


-- | This module exports a single typeclass <tt>IntervalAxioms</tt> which
--   contains property-based tests for the axioms in section 1 of <a>Allen
--   and Hayes (1987)</a>. The notation below is that of the original
--   paper.
--   
--   This module is useful if creating a new instance of interval types
--   that you want to test.
module IntervalAlgebra.RelationProperties

-- | A collection of properties for the interval algebra. Some of these
--   come from figure 2 in <a>Allen and Hayes (1987)</a>.
class (IntervalSizeable a b) => IntervalRelationProperties a b

-- | For any two pair of intervals exactly one <a>IntervalRelation</a>
--   should hold
prop_exclusiveRelations :: IntervalRelationProperties a b => Interval a -> Interval a -> Property

-- | Given a set of interval relations and predicate function, test that
--   the predicate between two interval is equivalent to the relation of
--   two intervals being in the set of relations.
prop_predicate_unions :: (IntervalRelationProperties a b, Ord a) => Set IntervalRelation -> ComparativePredicateOf2 (Interval a) (Interval a) -> Interval a -> Interval a -> Property
prop_IAbefore :: IntervalRelationProperties a b => Interval a -> Interval a -> Property
prop_IAstarts :: IntervalRelationProperties a b => Interval a -> Interval a -> Property
prop_IAfinishes :: IntervalRelationProperties a b => Interval a -> Interval a -> Property
prop_IAoverlaps :: IntervalRelationProperties a b => Interval a -> Interval a -> Property
prop_IAduring :: IntervalRelationProperties a b => Interval a -> Interval a -> Property
prop_disjoint_predicate :: (IntervalRelationProperties a b, Ord a) => Interval a -> Interval a -> Property
prop_notdisjoint_predicate :: (IntervalRelationProperties a b, Ord a) => Interval a -> Interval a -> Property
prop_concur_predicate :: (IntervalRelationProperties a b, Ord a) => Interval a -> Interval a -> Property
prop_within_predicate :: (IntervalRelationProperties a b, Ord a) => Interval a -> Interval a -> Property
prop_enclosedBy_predicate :: (IntervalRelationProperties a b, Ord a) => Interval a -> Interval a -> Property
prop_enclose_predicate :: (IntervalRelationProperties a b, Ord a) => Interval a -> Interval a -> Property
instance IntervalAlgebra.RelationProperties.IntervalRelationProperties GHC.Types.Int GHC.Types.Int
instance IntervalAlgebra.RelationProperties.IntervalRelationProperties Data.Time.Calendar.Days.Day GHC.Integer.Type.Integer
instance IntervalAlgebra.RelationProperties.IntervalRelationProperties Data.Time.Clock.Internal.UTCTime.UTCTime Data.Time.Clock.Internal.NominalDiffTime.NominalDiffTime