xkqV      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU  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. V is the principal  class member. WWNoneXYZ[\]^_XYZ[\]^_XYZ[\]^_ Safe-Inferred```None 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). aOptimal b on enumerations. The definition of pure for the applicative instance. ;Increases the cost of all values in an enumeration by one. @Constructs a reversable variant of a given list. In a sensible : Haskell implementation evaluating any inital segment of  reversals (toRevxs)0 uses linear memory in the size of the segment. c"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). d Padded zip eThe f is (disjoint)  gPure is  and h2 corresponds to cartesian product (as with lists) i@Only use fmap with bijective functions (e.g. data constructors) + jakcl mnopq!rstduegivwxyz{|}~hbf  !  ! "  jakcl mnopq!rstduegiNone$>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. /CDerive 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 3?Derive an instance of Enumberable with Template Haskell, with & rules for some specific constructors Contains only ASCII characters Not injective Not injective Not injective *"#$%&'()*+,-./0123"#$%&'()*+,-./0123'(#,-+.)*$%&/3"012'"#$%&'()*+,-./0123None4Printable ASCII characters 7Any unicode character. :A type of non empty lists. >'Smart constructor for unicode strings. ?.Smart constructor for printable ASCII strings 456789:;<=>?456789:;<=>?:;<=789>456? 456789:;<=>?NoneC1This function is best described with an example:   + let e1 = override $ addOverride (unary 6) 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 6! 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. @ABC@ABC@ABC@ABCNoneD7Functions that test a property and reports the result. EKMainly as a proof of concept (if this is repeated multiple times it might N be very inefficient, depending on whether the dictionary for the Enumerable F is shared or not) we define a function to index into an enumeration. FFAll values of the enumeration by increasing cost (which is the number N of constructors for most types). Also contains the cardinality of each list. GA 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. HHA 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. I4Check a property for all values up to a given size.   featCheck p prop = K p (M prop)  J5A 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. K Defined as  ioAll p = J (take p F)  L Defined as ioBounded n p = J (take p $ H n) M@Reports counterexamples to the given predicate by printing them N-Takes a function and a predicate on its input/output pairs. 6 Reports counterexamples by printing the failing input/ output pair. OGCompatibility with QuickCheck. Distribution is uniform generator over 0 values bounded by the given size. Typical use:  sized uniform. P Compatibility with SmallCheck. QNon class version of F. RNon class version of G. SNon class version of H. TNon class version of O. UNon class version of P. DEFGHIJKLMNOPQRSTUDEFGHIJKLMNOPQRSTUEFGHIJKLDMNOPQRSTUDEFGHIJKLMNOPQRSTU None$%&'()*+,-./DEFHIJKLMO'(),-$%&+./*EFHOIJKLDM       !"#$%&'()*+,-./01234567899:;;<==>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkfglmfnopqrstuvwxyz{|f}~f}f}f}f}f}f}f}fnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnffgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfgfffffff}f}f}f}f}f}f}f}f}f}f}f}f}f}f}f}f}f}f}f}f}f}f}f}f}f}ff}f}f}f}ftesting-feat-0.3.0.1Test.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 fromFiniteConstructorDeriv ConstructorFreePairFreefree Enumerable enumeratesharedoptimalfuncurrynullaryunaryconstsderiveEnumerabledAll dExcludingdExceptderiveEnumerable' Printable printableUnicodeunicodeNonEmptynonEmpty mkNonEmptyunicodes printablesOverride noOverride addOverrideoverrideReportindexvaluesstripedbounded featCheckioFeatioAll ioBoundedinputRep prePostRepuniformtoSeries valuesWith stripedWith boundedWith uniformWith toSeriesWith integer-gmpGHC.Integer.TypeInteger$fInfiniteInteger instanceFormkInstanceType extractDatatvbNameconDataxtoTypetupsClasseconcatbase Data.MonoidmconcatrevCons$fMonoidRevList$fMonoidEnumeratemappend$fApplicativeEnumerateControl.Applicative<*>$fFunctorEnumeratePartprodrevPurefinEmptyfinUnionsumSelfinCartfinPure $fShowFinite$fMonoidFinite$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