aqZ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY Safe+;A type of (infinite precision) non-zero integers such that  nonZero a /= 0 .9A type of (infinite precision) natural numbers such that  nat a >= 0 ..A class of infinite precision integral types. Z! is the principal class member.[[None\]^_`abc\]^_`abc\]^_`abcSafedddNone+ kA data structure that contains a list and the reversals of all initial segments of the list. Intuitively  5reversals xs !! n = reverse (take (n+1) (fromRev xs))Any operation on a RevListJ typically discards the reversals and constructs new reversals on demand.!A functional enumeration of type t is a partition of ty into finite numbered sets called Parts. Each parts contains values of a certain cost (typically the size of the value).eOptimal f on enumerations.The definition of pure for the applicative instance. :Increases the cost of all values in an enumeration by one.Constructs a "Reverse list" variant of a given list. In a sensible Haskell implementation evaluating any inital segment of  (toRev xs)/ uses linear memory in the size of the segment.g"Adds an element to the head of a RevListu. Constant memory iff the the reversals of the resulting list are not evaluated (which is frequently the case in Feat).!!Used to avoid non-termination of , in the presence of irregular data types.  irregular should be applied to the enumeration for the constructor that introduces the irregularity. Excessive use may impact performanceh Padded zipiThe j is (disjoint) kPure is  and l1 corresponds to cartesian product (as with lists)m?Only use fmap with bijective functions (e.g. data constructors)- neogp !qrstu"vwxyhzikm{l|}~fj  !"  " !$  neogp !qrstu"vwxyhzikmNone+%sA free pair constructor. The cost of constructing a free pair is equal to the sum of the costs of its components. ((A class of functionally enumerable types)RThis is the interface for defining an instance. When combining enumerations use *; instead and when accessing the data of enumerations use +.* Version of )y that ensures that the enumeration is shared between all accesses. Should always be used when combining enumerations.+An optimal version of enumerate. Used by all library functions that access enumerated values (but not by combining functions). Library functions should ensure that optimal is not reevaluated.,IUncurry a function (typically a constructor) to a function on free pairs.-!For nullary constructors such as True and []..'For any non-nullary constructor. Apply ,n until the type of the result is unary (i.e. n-1 times where n is the number of fields of the constructor)./fProduces the enumeration of a type given the enumerators for each of its constructors. The result of . should typically not be used directly in an instance even if it only has one constructor. So you should apply consts even in that case. 0TDerive an instance of Enumberable with Template Haskell. To derive an instance for  Enumerable Ai, just put this as a top level declaration in your module (with the TemplateHaskell extension enabled):  deriveEnumerable ''A 4dDerive an instance of Enumberable with Template Haskell, with rules for some specific constructorsContains only ASCII characters Not injective Not injective Not injective5#$%&'()*+,-./01234#$%&'()*+,-./01234()$-.,/*+%&'04#1232#$%&'()*+,-./01234None+5Printable ASCII characters8Any unicode character.;A type of non empty lists.?&Smart constructor for unicode strings.@-Smart constructor for printable ASCII strings56789:;<=>?@56789:;<=>?@;<=>89:?567@ 56789:;<=>?@NoneD0This function is best described with an example: * let e1 = override $ addOverride (unary 7) noOverride :: Enumerate T e1 enumerates values of type T, where all characters (accessed using the  Enumerable instance for CharD) are printable. Sometimes this can save you from placing lots of 7I modifiers in your instances or newtypes in your data type definitions.eThis works for any type (not just characters). This function should typically not be used when combining enumerations (doing so might increase memory usage because the resulting enumeration is optimised). Also this only has effect on enumerations which have not already been optimised, so using override again on the result of override has no effect.ABCDABCDABCDABCDNoneE6Functions that test a property and reports the result.FMainly as a proof of concept we define a function to index into an enumeration. (If this is repeated multiple times it might be very inefficient, depending on whether the dictionary for the Enumerable is shared or not.)GdA more fine grained version of index that takes a size and an index into the values of that size.  select p i is only defined for i HAll values of the enumeration by increasing cost (which is the number of constructors for most types). Also contains the cardinality of each list.IA generalisation of valuesf that enumerates every nth value of the enumeration from a given starting point. As a special case values = striped 0 1.7Useful for running enumerations in parallel since e.g.  striped 0 2 is disjoint from  striped 0 1 2+ and the union of the two cover all values.JA version of values with a limited number of values in each inner list. If the list corresponds to a Part which is larger than the bound it evenly distributes the values across the enumeration of the Part.K5Check a property for all values up to a given size.  featCheck p prop = M p (O prop) LA rather simple but general property testing driver. The property is an (funcurried) IO function that both tests and reports the error. The driver goes on forever or until the list is exhausted, reporting its progress and the number of tests before each new part.M Defined as  ioAll p = L (take p H) N Defined as ioBounded n p = L (take p $ J n)O?Reports counterexamples to the given predicate by printing themPTakes a function and a predicate on its input/output pairs. Reports counterexamples by printing the failing input/output pair.QwCompatibility with QuickCheck. Distribution is uniform generator over values bounded by the given size. Typical use:  sized uniform.RCompatibility with SmallCheck. SNon class version of F.TNon class version of GUNon class version of H.VNon class version of I.WNon class version of J.XNon class version of Q.YNon class version of R.EFGHIJKLMNOPQRSTUVW XYEFGHIJKLMNOPQRSTUVWXYFGHIJKLMNEOPQRSTUVWXYEFGHIJKLMNOPQRSTUVW XY None%&'()*+,-./0EFGHJKLMNOQ()*-.%&',/0+FGHJQKLMNEO        !"#$%&'()*+,-./0123456789::;<<=>>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnojkpqjkrstuvwxyz{|}~jjkjjkjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkjkjkjkjkjkjkjkjkjkjkjkjkjk   testi_IM5TLMnwhY6INEXLmigp0WTest.Feat.ModifiersTest.Feat.EnumerateTest.Feat.ClassTest.Feat.Class.OverrideTest.Feat.AccessTest.Feat.Internals.NewtypesTest.Feat.Internals.DeriveTest.Feat.Internals.Tag Test.FeatNonZerononZeroNatnatInfiniteTagSourceFinitefCardfIndexRevListfromRev reversals EnumeraterevParts optimiserIndexparts fromParts cartesianunion singletonpaytoReveSharetagoptimisenoOptim irregular fromFiniteConstructorDeriv ConstructorFreePairFreefree Enumerable enumeratesharedoptimalfuncurrynullaryunaryconstsderiveEnumerabledAll dExcludingdExceptderiveEnumerable' Printable printableUnicodeunicodeNonEmptynonEmpty mkNonEmptyunicodes printablesOverride noOverride addOverrideoverrideReportindexselectvaluesstripedbounded featCheckioFeatioAll ioBoundedinputRep prePostRepuniformtoSeries indexWith selectWith valuesWith stripedWith boundedWith uniformWith toSeriesWith integer-gmpGHC.Integer.TypeInteger$fInfiniteInteger instanceFormkInstanceType extractDatatvbNameconDataxtoTypetupsClasseconcatbaseGHC.BasemconcatrevCons$fMonoidRevList$fMonoidEnumeratemappend$fApplicativeEnumerate<*>$fFunctorEnumeratePartprodrevPurefinEmptyfinUnionsumSelfinCartfinPure $fShowFinite$fMonoidFinite$fApplicativeFinite$fFunctorFinite$fFunctorRevListData.Typeable.InternalmkAppTypureTypeable ApplicativeTypeRepControl.ApplicativeoptionalgetConstConst unwrapMonad WrapMonad WrappedMonad unwrapArrow WrapArrow WrappedArrow getZipListZipList Data.Monoid<>getDualDualappEndoEndogetAllAllgetAnyAnygetSumSum getProductProductgetFirstFirstgetLastLastgetAltAlt Data.Typeablegcast2gcast1gcasteqTcastrnfTyCon rnfTypeRep showsTypeReptypeOf7typeOf6typeOf5typeOf4typeOf3typeOf2typeOf1typeOftypeReptypeRepFingerprint tyConString typeRepArgs typeRepTyConmkTyCon3 funResultTy splitTyConAppmkFunTy mkTyConApp tyConName tyConModule tyConPackagetyConFingerprintTyCon Typeable1 Typeable2 Typeable3 Typeable4 Typeable5 Typeable6 Typeable7 Data.ProxyProxyData.Type.EqualityRefl:~: Data.Functor<$>liftA3liftA2liftA<**>memptyMonoid<$<**>manysome<|>empty Alternative$fEnumerableChar$fEnumerableRatio$fEnumerableFloat$fEnumerableDouble simpleEnumwordintcutOffbitSize'$fEnumerableOrdering$fEnumerableMaybe$fEnumerableEither$fEnumerable(,,,,,,)$fEnumerable(,,,,,)$fEnumerable(,,,,)$fEnumerable(,,,)$fEnumerable(,,)$fEnumerable(,)$fEnumerable()$fEnumerableBool$fEnumerable[]$fEnumerableInt64$fEnumerableInt32$fEnumerableInt16$fEnumerableInt8$fEnumerableInt$fEnumerableWord64$fEnumerableWord32$fEnumerableWord16$fEnumerableWord8$fEnumerableWord$fEnumerableNonZero$fEnumerableInteger$fEnumerableNat$fEnumerableFreePairenumerateBounded$fEnumerablePrintable$fEnumerableUnicode$fEnumerableNonEmpty samplePart