7j      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi  #neverEmptyList2List (NEL h t) = h:t  list2NeverEmptyList [] = Nothing *list2NeverEmptyList (h:t) = Just (NEL h t)        3HasCardT = "-Has cardinality (for container types of kind (* -> *))".  In other words, "it's possible to measure F current count of elements for this container (for container types of  kind (* -> *))" HasCard = "Has cardinality". In other words, "it's possible to measure - current count of elements for this container" 2In other words: count of elements in a container, F with an opportunity not to refine the whole content of the container  (and the container's structure). Constructors:      jklAn example of this is 9 function. "Count of elements in container. It's always positive or zero. It would be best here to use m instead, however, with Integer  it'>s easier to catch the error of going down below zero (in case  of m 0-1==4294967295 ). 5However it is decided not to allow the direct use of k data + constructor, but to wrap it into function , which guards from G the attemts to conctruct negative cardinality (by throwing an error).  constructor. F.e., [1..] list has such cardinality. 5 constructor. If given negative value, raises error. F.e., the tuple (5,6) has a precise cardinality 2.  constructor. DFor lists it happens, that we do not want to count all the elements  of a container, @ but want to count them until some lower boundary. For example, E I do not want to know the length of the list (which involves taking A each element of it, and counting it in) to reason about whether  it's content fit into the (,,) data constructor. For this B case I only need to count till 3rd element and check, if list is  continued. It'6s actual especially, when dealing with infinite lists ) or with lists, whose reading may block. For (refinableC (x0, refine_f)) important rules:   If (refine_f x0 (<= 5)) evaluates to another  refinableC, then ) it is not fully refined, but (at least) 5 is achieved (the precise  cardinality is >= 5).  If x0 is 10 and (refine_f 10 (<= 15)) returned  (refinableC (17, refine_f_2))!, then it is known, that precise  cardinality is already >= 10 + 7. In sight of refine_f there % SHOULD be everything except for what's already counted in x0  (which is 10), and in sight of  refine_f_2 there should be even  less by 7 elements comparing to refine_f. So if total cardinality was  25, then (refine_f_2 17 (<= 30)) MUST return  preciseC 25 , to make  10 + 7 + 8 = 25. < The theatment of the first argument of refinement function refine_f > must be relative. For example, given total count of elements = 25 ,  and x0 = 20: - these 20 elements are already counted, and in sight of  refine_f! there are only 5 last elements.  Then  refine_f 20 (<= 26) will result in  preciseC 25 , but(!)   refine_f 10 (<= 16) MUST result in  preciseC 15. Recomendations: ( If subject has infinite cardinality, it's best to determine  it's cardinality as  at early stages and  avoid using  refinableC for it. noReturns Nothing, ONLY if LC is  (0, _) 6 (according to 2nd assumption of the module). Returns  Just True  only for  0.  FFor case when adding up 2 refinables, if both of them sooner or later  refines to ,, then one that returns infinity earlier is D recommended to put as a first term. Infinity + any LazyCardinality 4 = infinity. Another recommendation would be to put  refinable that'%s easier to compute as a first term. ! foldl  See recommendations by  . "#$%&Don'2t use it on infinite refinables not measured with . 'Wrapper around ". (Wrapper around (. )Wrapper around ). *Wrapper around %. +Wrapper around &. ,For .equalize2Refinements (m, ref_f_1) (n, ref_f_2) finishes when m == n. G Else refines them. Another termination condition is when in result of 4 refinement one of cardinalities becomes final (not ). -.$Used for instance of Ord typeclass. Together with p- returns also probably refined cardinalities  for reuse. WARNING!!! When comparing  with   , it results in q (less than)!  While comparing  `almostStrictCompare2LCs`  ==  r.  That's the reason for an almost- prefix in function name. . If there is a probability that refinement of   may evaluate to , and it's important to you, B that infinities are equal, then before comparing this refinable,  use & on it. That' s laziness. Trying to compare 2 %s that are actually infinite, but don't  use  will hang G the system (the same as if you try to determine length of an infinite  list). /Won'@t refine refinables. According to 2nd assumption of the module:   (m, _) `lazyCompare2LCs`  n equals to Just GT if m > n , and Nothing otherwise. 0+Used for Show typeclass instaniation. Here  isn' t refined. 1Here  & is applied to  argument. 23456 Refinable starting from 0, uses 9 7Not refinable, since s is a strict structure. 8Refinable starting from 1. 9'List length of controlable greediness. tuv+ !"#$%&'()*+,-./0123456789+ !"#$%&'()*+,-./0123456789+ !"#$%&'()*+,-./01234567891:;<= HasCardUCT_T = "!Has cardinality-unsafe container ( transform (for container types of kind (* -> *))".  Same thing as ?, but for containers of kind (* -> *). >"u-" prefix stands for "unsafe-" ? HasCardUCT = "*Has cardinality-unsafe container transform". 9 Define transform that may thow an error, if contents of from don't fit  in to . @"u-" prefix stands for "unsafe-" AHasCardConstrT = "3Has cardinality constraint (for container types of  kind (* -> *))".  In other words, "7there is a capacity constraint for this container type  of kind (* -> *)". BC HasCardConstr = "Has cardinality constraint". In other words, "there , is a capacity constraint for this container". DEF'Error, that may occur, when performing U GHUsed in F IJK Constructor: N M L wLMNCardinalityRange3 data constructor. The range is always including it's  boundaries. F.e., range  K ( 1) ( 4) contains  cardinalities [1,2,3,4]. H First cardinality MUST always be less or equal to second one. However, B we do not fully guard from such type of error - we do not refine  *, if it participates in the constriction. OPQ"Root prototype for all subsequent "FitsIn" functions. Returns probably ; refined cardinality and range, which is useful for reuse.  If returns EQ then subject cardinality 9 is between boundaries (including) of cardinality range. R fits in K? SWrapper around R. TWrapper around R. UFThis function is made hard, but fast. It tends to make minimal amount & of comparisons, reusing refinements. VWrapper around  of typeclass  WSame as [. XOnly zero elements. YOnly one element. ZZero or one element. [Any count of elements. \Any nonzero count of elements. ]Concrete count of elements. ^A concrete range. _  cFitsInCC = R!Defined to satisfy abbreviation. `  fitsInCC = S!Defined to satisfy abbreviation. a  fitsInCC = T!Defined to satisfy abbreviation. bWrapper around _. cWrapper around _. dWrapper around _. eWrapper around _. fThis error is used by ? # typeclass instances in cases when from container' s contents  don' t fit in to container. gSame as f, but for use in  = typeclass instances hA wrapper around @. Contrary to it, where "u-" prefix stands  for "unsafe-", here "s-" prefix stands for "safe-". > This is aimed to localize and exclude case, when contents of from don't  fit in to If ? instaniated  correctly, then h should never allow  f4 to be called by subject instance. It should return Nothing  instead. iA wrapper around >. Contrary to it, where "u-" prefix stands  for "unsafe-", here "s-" prefix stands for "safe-". > This is aimed to localize and exclude case, when contents of (from a) don't  fit in (to a) . If = instaniated  correctly, then i should never allow  g4 to be called by subject instance. It should return Nothing  instead. 0:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi0MLKNOPQRSTHJIFGUVWXYZ[\]^E_`aCDABbcde?@=><;:fghi0:;<=>>?@@ABBCDDEFGGHJIIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghix      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxywxzwx{|}~PCardinality-0.1Data.IntersectableData.NeverEmptyList Data.EmptySetData.CardinalityData.CardinalityRange IntersectablesetFitsSetsFit EqualSets SecondInFirst FirstInSecond IntersectionNoIntersectionNeverEmptyListNELnel2Listlist2nel nelSingletonEmptySetHasCardTcardOfTHasCardcardOfLazyCardinalityCardinalityRefinementState ContinueRefiningCardinalityUntilContinueCounting_DoWeBoundaryPreciseCardinality!CurrentNotFinalPreciseCardinalityPreciseCardinality infiniteCpreciseC refinableC lazyIsZeroLCrefinementState addPCToLC addLCToLCsumLCsrefineCRS_TillrefineCRS_TillOneAboverefineCRS_TillOneBelowcrsRefinementSteprefineCRS_TillEnd refineTillrefineTillOneAboverefineTillOneBelowrefinementStep refineTillEndequalize2Refinementscompare2RefinementsalmostStrictCompare2LCslazyCompare2LCsshowLazy showStrict cardOf_UnitycardOf_EmptySetcardOf_Identity1 cardOf_Maybe cardOf_List cardOf_MapcardOf_NeverEmptyListlength2TransformError_DetailsTransformError_ToTypeNameTransformError_FromTypeName HasCardUCT_T uContTransT HasCardUCT uContTransHasCardConstrTcardinalityConstraintOfT HasCardConstrcardinalityConstraintOfCardinalityConstraintCompare2CRsErrorLowerBoundaryAfterHigher FirstOrSecondSecondFirstCardinalityRangeCardinalityRange_ToCardinalityRange_FromcardinalityRangecr2Tuple lazyVerfyCRcFitsInCR_Proto cFitsInCRfitsInCR fitsInCR_T compare2CRs crFitsInCRcrNoConstraintcr0cr1cr0_1cr0_Infcr1_InfcrXcrXY cFitsInCCfitsInCC fitsInCC_TcFitsIncFitsInTfitsInfitsInT uContError uContErrorT sContTrans sContTransT RefinableCPreciseC InfiniteCbaseGHC.WordWord32 lcIsInfinite preciseOfLCghc-prim GHC.OrderingOrderingLTEQcontainers-0.3.0.0Data.MapMapfst3snd3thrd3