rDj]I      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHNone+2346HM/This is a data type specifying an inclusive interval between exactly two points (which may be the same point). This is the building block of an  .5Enumerable elements with the possibility of infinity.a single pointpositive infinitynegative infinityDescribes a class of data types that contained a range of values described by an upper and lower bound, a subset of the range of values of the   and   . Unlike I or  ', this class describes data types like JNs which contain information about the upper and lower bound of the data type. Like I2, except the bounds might be infinite, and return  or  for the bounds. Using the GHC "flexible instances" and "undecidable instances" feature, any data type that is an instance of I is also a memberM of BoundInf.-Increment a given value, but if the value is K , return ?. In some circumstances this is better than incrementing with  L because L$ evaluates to an error when passing KA as the argument. This function will never evaluate to an error.-Decrement a given value, but if the value is M , returns :. In some circumstances this is better than incrementing  N because N$ evaluates to an error when passing KA as the argument. This function will never evaluate to an error.#Retrieve the value contained in an , if it exists.If the  was constructed with single, return the pointM (possibly  or /) value used to construct it, otherwise return .If the  was constructed with $, return a pair of points (possibly  or /) value used to construct it, otherwise return .=This gets rid of as many infiniteM elements as possible. All O  and O " points are eliminated, and if an  or ' can be replaced with a corresponding   or  d, then it is. This function is intended to be used as a list monadic function, so use it like so: 5let myListOfSegments = [...] in myListOfSegments >>=  delInfPoints=A predicate evaluating whether or not a interval includes an  or  value. This should not be confused with a predicate evaluating whether the set of elements included by the rangeM is infiniteM, because types that are instances of I may also contain  or h elements, values of these types may be evaluated as "infintie" by this function, even though they are I,. To check if a interval is infiniteM, use  instead.NA predicate evaluating whether or not a interval is infiniteM. Types that are ID are always finite, and thus this function will always evaluate to P for these types.Q Construct a  from two  items. *NOTE* if the . type you are constructing is an instance of I , use the boundedInterval& constructor instead of this function. Construct a  from two values. Construct a ? that is only a single unit, i.e. it starts at X and ends at X. Construct a ) from negative infinity to a given value. Construct a ) from a given value to positive infinity.Construct the infiniteM 9Tests whether an element is a memberM is enclosed by the .If an  is also I6 then you can convert it to some value in the set of I items.  translates to M,  translates to K, and ( translates to the value at that pointM.Like :, but operates on a interval and returns a pair of values.!Construct the minimum 0 that is big enough to hold both given segments."Computes the minimum ( that can contain the list of all given  EnumRanges.  indicates the empty set.#DEvaluates to the number of elements covered by this region. Returns ] if there are an infinite number of elements. For data of a type that is not an instance of R, for example  S, use $ instead, or else  the element type to an T.$Like #, but works on s of U elements rather than R elements.%NReturn the number of points included the set for sets of points that are both I and R.&NReturn the number of points included the set for sets of points that are both I and U.'Tests whether an I is within the _interval. It is handy when used with backquote noation: enumInf ' _interval(Returns true if two s are intersecting.)Returns true if two /s are consecutive, that is, if the end is the N"ecessor of the start of the other.*Performs a set union on two s of elements to create a new _interval. If the elements of the new _interval are not contiguous, each _interval is returned separately and unchanged. The first item in the pair of items returned is V# if any of the items were modified.+#Performs a set intersection on two s of elements to create a new _interval. If the elements of the new _interval are not contiguous, this function evaluates to an empty list.,Performs a set "delete" operation, deleteing any elements selected by the first _interval if they are contained in the second _interval. This operation is not associative, i.e. , a b /= , b a.-BAnalogous to a bitwise exclusive-OR operation, returns the set of s produced from combining two %s such that only the portions of the %s that do not interlap are included..?Evaluates to the set of all elements not selected by the given ./$Eliminate overlapping and duplicate s from a list of segments.07This function takes a multiplication function, usually + or ,y. It works like polynomial multiplication, with the provided reduction function computing the product of every pair of $s, and then the "sum" (actually the *") of all products are taken. The W and C, functions are defined to use this function.1w is not a functor, but you can map over values as long as the type of values you map to satisfy the class constraints X, Y, U, and  ; Evaluate an T size on a set of I R elements.< Evaluate an Z size on a set of I U elements.=Evaluate a possibly infinite T3 value counting the number of elements in the set.?V if the  is null.@V if the  spans the 3 interval.CSExclusive union, similar to the binary exclusive-OR operator, returns the union of a and b excluding all s where a and b W. This function is equal to /(a `'union'` b) `'delete'` (a `'intersect'` b) [\]^_`abcdeO f ghQ !"#$%&'()i*j+k,-./l0m1nop23qr45678s9:;<t=u>?@vABwCxDEyFGzH{|}~I  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHL  /.*+,-() !"#$%&'234567819;<=:>?@ABCDEGFH0y[\]^ba`_cdOe  f ghQ !"#$%&'()i*j+k,-./l0m1nop23qr45678s9:;<t=u>?@vABwCxDEyFGzH{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQORSOPTOPUOPVOPWXYZ[\O]^YZ_`abOPcYZdOeLYfgYfhYZijjkllmnopqrstuvwxyz{|}~inf-interval-0.1.0.1Numeric.Interval.Infinite Data.Functorfmap Data.MaybeNothingSetIntervalendPoint startPointInfFinitePosInfNegInf SubBounded subBoundsInfBound minBoundInf maxBoundInf enumIsInfstepUpstepDowntoFinitetoPairfromPairsingularpluralcanonicalIntervalintervalHasEnumInfintervalIsInfiniteintervalpointnegInfTotoPosInf wholeIntervalintervalMember toBounded toBoundedPairenumBoundedPairenvelopintervalSpanAll intLength enumLengthintervalIntSizeintervalEnumSizeisWithinareIntersectingareConsecutive intervalUnionintervalIntersectintervalDeleteintervalExclusionintervalInvert intervalNub innerProductmapemptywholefromList fromPairs fromPointsrange singletontoListelemsintSizeenumSize cardinalitymembernullisWhole isSingletoninvert exclusiveunionunions intersect intersectionsdeletebaseGHC.EnumBoundedGHC.ArrArraymaxBoundsuccminBoundpredSingleghc-prim GHC.TypesFalse _intervalGHC.RealIntegralChar integer-gmpGHC.Integer.TypeIntegerEnumTrue Data.List GHC.ClassesEqOrdIntList _unwrapListSet_ InverseSet InfiniteSetEmptySet _unwrapSet_paren_mkSeg _canonicalize_intervalUnion_intervalIntersect_intervalDelete _innerProduct _exclusive_set_vecSet_listSet _fromList _normalize_toList _cardinality_member _isSingleton_invert_union _intersect_delete $fNFDataSet_ $fReadSet_ $fShowSet_ $fOrdSet_$fEqSet_ $fEqSet_0 $fFunctorSet_ $fFunctorList $fNFDataSet$fMonoidProduct $fMonoidSum $fReadSet $fShowSet$fNFDataInterval$fReadInterval$fShowInterval $fOrdInterval$fFunctorInterval $fMonoidInf$fOrdInf $fNFDataInf $fFunctorInf$fSubBounded(,)i$fSubBoundedArrayi$fSubBoundedIntervali$fInfBoundDouble$fInfBoundFloat$fInfBoundRatio$fInfBoundInteger$fInfBoundChar $fInfBoundInt $fInfBound()