VrZ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY  Safe-Inferred;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\]^_`abc Safe-InferreddddNone HA 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 RevList1 typically discards the reversals and constructs  new reversals on demand. !A functional enumeration of type t is a partition of  tD into finite numbered sets called Parts. Each parts contains values 6 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)0 uses linear memory in the size of the segment. g"Adds an element to the head of a RevList. Constant memory iff the M 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 I constructor that introduces the irregularity. Excessive use may impact  performance h Padded zip iThe j is (disjoint)  kPure is  and l2 corresponds to cartesian product (as with lists) m@Only use fmap with bijective functions (e.g. data constructors) - neogp !qrstu"vwxyhzikm{|}~lfj  !"  " !$  neogp !qrstu"vwxyhzikmNone%>A free pair constructor. The cost of constructing a free pair 6 is equal to the sum of the costs of its components. ()A class of functionally enumerable types )@This is the interface for defining an instance. When combining  enumerations use *) instead and when accessing the data of  enumerations use +. * Version of ). that ensures that the enumeration is shared 3 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. ,JUncurry a function (typically a constructor) to a function on free pairs. -!For nullary constructors such as True and []. .'For any non-nullary constructor. Apply , until the type of F the result is unary (i.e. n-1 times where n is the number of fields  of the constructor). /IProduces the enumeration of a type given the enumerators for each of its  constructors. The result of . should typically not be used F directly in an instance even if it only has one constructor. So you ) should apply consts even in that case. 0CDerive an instance of Enumberable with Template Haskell. To derive  an instance for  Enumerable A,, just put this as a top level declaration > in your module (with the TemplateHaskell extension enabled):   deriveEnumerable ''A 4?Derive an instance of Enumberable with Template Haskell, with & rules for some specific constructors Contains only ASCII characters Not injective Not injective Not injective *#$%&'()*+,-./01234#$%&'()*+,-./01234()$-.,/*+%&'04#123'#$%&'()*+,-./01234None5Printable ASCII characters 8Any unicode character. ;A type of non empty lists. ?'Smart constructor for unicode strings. @.Smart constructor for printable ASCII strings 56789:;<=>?@56789:;<=>?@;<=>89:?567@ 56789:;<=>?@NoneD1This 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 Char*) are printable. Sometimes this can save  you from placing lots of 7! modifiers in your instances or ) newtypes in your data type definitions. OThis works for any type (not just characters). This function should typically J not be used when combining enumerations (doing so might increase memory 8 usage because the resulting enumeration is optimised). H Also this only has effect on enumerations which have not already been M optimised, so using override again on the result of override has no effect. ABCDABCDABCDABCDNoneE7Functions that test a property and reports the result. F@Mainly as a proof of concept we define a function to index into A 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.) G?A 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 HFAll values of the enumeration by increasing cost (which is the number N of constructors for most types). Also contains the cardinality of each list. IA generalisation of values) 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. JHA version of values with a limited number of values in each inner list. L If the list corresponds to a Part which is larger than the bound it evenly < distributes the values across the enumeration of the Part. K4Check a property for all values up to a given size.   featCheck p prop = M p (O prop)  L5A rather simple but general property testing driver. N The property is an (funcurried) IO function that both tests and reports the D 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 them P-Takes a function and a predicate on its input/output pairs. 6 Reports counterexamples by printing the failing input/ output pair. QGCompatibility with QuickCheck. Distribution is uniform generator over 0 values bounded by the given size. Typical use:  sized uniform. R Compatibility with SmallCheck. SNon class version of F. TNon class version of G UNon class version of H. VNon class version of I. WNon class version of J. XNon class version of Q. YNon class version of R. EFGHIJKLMNOPQRSTUVWXYEFGHIJKLMNOPQRSTUVWXYFGHIJKLMNEOPQRSTUVWXYEFGHIJKLMNOPQRSTUVWXY None%&'()*+,-./0EFGHJKLMNOQ()*-.%&',/0+FGHJQKLMNEO       !"#$%&'()*+,-./0123456789::;<<=>>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnojkpqjrstuvwxyz{|}~jjjjjjjjjrjrjrjrjrjrjrjrjrjrjrjrjrjrjrjrjrjrjrjrjrjrjrjrjrjrjjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjkjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjtesting-feat-0.4Test.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 extractDatatvbNameconDataxtoTypetupsClasseconcatbase Data.MonoidmconcatrevCons$fMonoidRevList$fMonoidEnumeratemappend$fApplicativeEnumerateControl.Applicative<*>$fFunctorEnumeratePartprodrevPurefinEmptyfinUnionsumSelfinCartfinPure $fShowFinite$fMonoidFinite$fApplicativeFinite$fFunctorFinite$fFunctorRevListData.Typeable.InternalTypeable Typeable1 Typeable2 Typeable3 Typeable4 Typeable5 Typeable6 Typeable7 ApplicativeoptionalliftA3liftA2liftA<**><**>puremanysome<|>empty AlternativegetConstConst unwrapMonad WrapMonad WrappedMonad unwrapArrow WrapArrow WrappedArrow getZipListZipList Data.Functor<$><>memptyMonoidgetDualDualappEndoEndogetAllAllgetAnyAnygetSumSum getProductProductgetFirstFirstgetLastLast Data.Typeablegcast2gcast1gcastmkTyCon typeRepKey TypeRepKey showsTypeReptypeOf6DefaulttypeOf5DefaulttypeOf4DefaulttypeOf3DefaulttypeOf2DefaulttypeOf1Default typeOfDefault tyConString typeRepArgs typeRepTyConmkTyCon3mkAppTy funResultTy splitTyConAppmkFunTy tyConName tyConModule tyConPackagetypeOf1typeOf2typeOf3typeOf4typeOf5typeOf6typeOf7cast mkTyConAppTypeRepTyContypeOfGHC.Base<$$fEnumerableChar$fEnumerableRatio$fEnumerableFloat$fEnumerableDouble$fEnumerableFreePair simpleEnumwordintcutOffbitSize'$fEnumerableInt64$fEnumerableInt32$fEnumerableInt16$fEnumerableInt8$fEnumerableInt$fEnumerableWord64$fEnumerableWord32$fEnumerableWord16$fEnumerableWord8$fEnumerableWord$fEnumerableNonZero$fEnumerableInteger$fEnumerableNat$fEnumerable[]enumerateBounded$fEnumerablePrintable$fEnumerableUnicode$fEnumerableNonEmpty samplePart