h$H6\      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(C) 2011-2015 Edward Kmett, BSD-style (see the file LICENSE)Edward Kmett  experimental non-portable Trustworthy'(-./23>?'  constraintsReify the relationship between an instance head and its body as a classGiven a definition such as instance Foo a => Foo [a] you can capture the relationship between the instance head and its body with instance Foo a   Foo [a] where   =    constraintsReify the relationship between a class and its superclass constraints as a classGiven a definition such as class Foo a => Bar a you can capture the relationship between 'Bar a' and its superclass 'Foo a' with  instance   (Foo a) (Bar a) where   =   ,Now the user can use 'cls :: Bar a :- Foo a'  constraintsAny inhabits every kind, including  but is uninhabited, making it impossible to define an instance. constraintsThis is the type of entailment.a  b is read as a "entails" b./With this we can actually build a category for  resolution.e.g.Because  a is a superclass of  a, we can show that  a entails  a.Because  instance  a =>  [a] exists, we can show that  a entails  [a] as well.%This relationship is captured in the  entailment type here.Since p  p and entailment composes,  forms the arrows of a  of constraints. However,  only became sufficiently general to support this instance in GHC 7.8, so prior to 7.8 this instance is unavailable.But due to the coherence of instance resolution in Haskell, this  has some very interesting properties. Notably, in the absence of IncoherentInstances, this category is "thin", which is to say that between any two objects (constraints) there is at most one distinguishable arrow.This means that for instance, even though there are two ways to derive  a   [a], the answers from these two paths _must_ by construction be equal. This is a property that Haskell offers that is pretty much unique in the space of languages with things they call "type classes".What are the two ways?Well, we can go from  a   a1 via the superclass relationship, and then from  a   [a]& via the instance, or we can go from  a   [a] via the instance then from  [a]   [a] through the superclass relationship and this diagram by definition must "commute".Diagrammatically,  Ord a ins / \ cls v v Ord [a] Eq a cls \ / ins v v Eq [a]This safety net ensures that pretty much anything you can write with this library is sensible and can't break any assumptions on the behalf of library authors. constraints4Type entailment, as written with a single character. constraintsWitnesses that a value of type e% contains evidence of the constraint c.Mainly intended to allow (1) to be overloaded, since it's a useful operator. constraintsValues of type  p/ capture a dictionary for a constraint of type p.e.g.  ::  ( ) -captures a dictionary that proves we have an:  instance   Pattern matching on the 1 constructor will bring this instance into scope. constraintsFrom a , takes a value in an environment where the instance witnessed by the  is in scope, and evaluates it."Essentially a deconstruction of a # into its continuation-style form./Can also be used to deconstruct an entailment, a  b, using a context a.  withDict :: ( c -> (c => r) -> r withDict :: a => (a  c) -> (c => r) -> r  constraintsOperator version of , with the arguments flipped constraintsTransitivity of entailment If we view ()0 as a Constraint-indexed category, then this is () constraintsReflexivity of entailment If we view ()0 as a Constraint-indexed category, then this is  constraints3Convert a quantified constraint into an entailment.#Only available on GHC 8.6 or later. constraints due to the hack for the kind of (,) in the current version of GHC we can't actually make instances for -(,) :: Constraint -> Constraint -> Constraint, but (,) is a bifunctor on the category of constraints. This lets us map over both sides. constraintsWeakening a constraint productThe category of constraints is Cartesian. We can forget information. constraintsWeakening a constraint productThe category of constraints is Cartesian. We can forget information.  constraints,Contracting a constraint / diagonal morphismThe category of constraints is Cartesian. We can reuse information.! constraintsConstraint product 7trans weaken1 (f &&& g) = f trans weaken2 (f &&& g) = g" constraintsEvery constraint implies truth3These are the terminal arrows of the category, and () is the terminal object.9Given any constraint there is a unique entailment of the ()! constraint from that constraint.# constraints-This demonstrates the law of classical logic 3http://en.wikipedia.org/wiki/Principle_of_explosion"ex falso quodlibet"$ constraints$Apply an entailment to a dictionary.&From a category theoretic perspective  is a functor that maps from the category of constraints (with arrows in -) to the category Hask of Haskell data types.% constraintsThis functor is fully faithful, which is to say that given any function you can write Dict a -> Dict b! there also exists an entailment a :- b4 in the category of constraints that you can build.3 constraintsAssumes IncoherentInstances doesn't exist.4 constraintsAssumes IncoherentInstances doesn't exist.5 constraintsPossible since GHC 7.8, when  was made polykinded.  !"#$% ! "#$%  9 9 9 1(C) 2015-2016 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett  experimental non-portableNone'(-./3,A constraints>Allow an attempt at resolution of a constraint at a later time constraints Resolve a $ constraint with observable failure. constraintsDefer a constraint for later resolution in a context where we want to upgrade failure into an error constraints A version of 2 that uses visible type application in place of a .#Only available on GHC 8.0 or later. constraints A version of 2 that uses visible type application in place of a .#Only available on GHC 8.0 or later. constraints-Deferrable heterogenous equality constraints.#Only available on GHC 8.0 or later. constraints,Deferrable homogeneous equality constraints.#Note that due to a GHC bug (https:/ghc.haskell.orgtracghcticket/10343), using this instance on GHC 7.10 will only work with *-kinded types.  (C) 2011-2015 Edward Kmett, (C) 2015 rjan Johansen, (C) 2016 David Feuer BSD-style (see the file LICENSE)Edward Kmett  experimental non-portable Trustworthy-.>1*  constraintsInstantiate a quantified  p constraint as c , where c ~ p a1 a2 ... an. constraints/A representation of the quantified constraint $forall a1 a2 ... an . p a1 a2 ... an., supporting a variable number of parameters. constraints.A representation of the quantified constraint forall f a. p (t f a). constraints.A representation of the quantified constraint forall a. p (f a). constraints.A representation of the quantified constraint  forall a. p a. constraintsInstantiate a quantified  p constraint at type a. constraintsInstantiate a quantified  p f constraint at type a. constraintsInstantiate a quantified  p t constraint at types f and a. constraints,Instantiate a quantified constraint on kind * -> *. This is now redundant since  became polykinded.  None-.9>1 Trustworthy-./1None-./3 constraintsAn infix synonym for .5(C) 2011-2015 Edward Kmett BSD-style (see the file LICENSE)Edward Kmett  experimental non-portableUnsafe '(->6B constraints5Coerce a dictionary unsafely from one type to another constraintsCoerce a dictionary unsafely from one type to a newtype of that type constraintsCoerce a dictionary unsafely from a newtype of a type to the base type constraints.Construct an Applicative instance from a Monad constraints2Construct an Alternative instance from a MonadPlus          !""#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     'constraints-0.13-11CyTXQ5hZr3AUcuVeWizHData.ConstraintData.Constraint.NatData.Constraint.UnsafeData.Constraint.SymbolData.Constraint.DeferrableData.Constraint.ForallData.Constraint.Liftingghc-prim GHC.Types Constraintbase GHC.TypeNatsDivMod Coercible GHC.TypeLits AppendSymbolData.Type.EqualityRefl:~:HRefl:~~::=>insClassclsBottomno:-Sub⊢HasDictevidenceDictwithDict\\transreflimplied***weaken1weaken2 strengthen1 strengthen2contract&&&topbottommapDict unmapDict $fMonoidDict$fSemigroupDict $fBoundedDict $fEnumDict $fNFDataDict $fDataDict$fHasDict(%,%)TypeRep$fHasDict~~:~~: $fHasDict~:~:$fHasDictCoercibleCoercion$fHasDictaDict $fNFData:-$fShow:-$fOrd:-$fEq:-$fCategoryTYPE:-$fData:- $fHasDictb:-$fClass(%,%)MonadPlus$fClassApplicativeMonad$fClassApplicativeAlternative$fClassFunctorApplicative$fClass(%%)Functor$fClassSemigroupMonoid$fClass(%%)Semigroup$fClass(%,%)RealFloat$fClass(%,%)RealFrac$fClassFractionalFloating$fClassNumFractional $fClassEqBits$fClass(%,%)Integral$fClass(%,%)Real$fClass(%%)Num$fClass(%%)Bounded$fClass(%%)Enum$fClass(%%)Read$fClass(%%)Show $fClassEqOrd $fClass(%%)Eq$fClass(%%)(%%)$fClass(%%)Class $f:=>aMonoid$f:=>(%%)Semigroup $f:=>aRead $f:=>aBounded $f:=>aEnum$f:=>(%%)MonadPlus$f:=>(%%)MonadPlus0$f:=>(%%)Monad$f:=>(%%)Monad0$f:=>(%%)Monad1$f:=>(%%)Monad2$f:=>(%%)Monad3$f:=>MonadPlusAlternative$f:=>(%%)Alternative$f:=>(%%)Alternative0$f:=>MonadApplicative$f:=>MonoidApplicative$f:=>MonoidApplicative0$f:=>(%%)Applicative$f:=>(%%)Applicative0$f:=>(%%)Applicative1$f:=>(%%)Applicative2$f:=>(%%)Applicative3$f:=>(%%)Functor$f:=>(%%)Functor0$f:=>MonadFunctor$f:=>(%%)Functor1$f:=>(%%)Functor2$f:=>(%%)Functor3$f:=>(%%)Functor4$f:=>(%%)Functor5$f:=>(%%)Functor6$f:=>MonoidMonoid$f:=>MonoidMonoid0$f:=>MonoidMonoid1$f:=>(%,%)Monoid$f:=>MonoidMonoid2$f:=>(%%)Monoid$f:=>(%%)Monoid0$f:=>(%%)Monoid1$f:=>SemigroupSemigroup$f:=>SemigroupSemigroup0$f:=>SemigroupSemigroup1$f:=>(%,%)Semigroup$f:=>SemigroupSemigroup2$f:=>(%%)Semigroup0$f:=>(%%)Semigroup1$f:=>(%%)Semigroup2$f:=>RealFloatRealFloat$f:=>RealFloatRealFloat0$f:=>(%%)RealFloat$f:=>(%%)RealFloat0$f:=>RealFracRealFrac$f:=>RealFracRealFrac0$f:=>IntegralRealFrac$f:=>(%%)RealFrac$f:=>(%%)RealFrac0$f:=>FloatingFloating$f:=>FloatingFloating0$f:=>RealFloatFloating$f:=>(%%)Floating$f:=>(%%)Floating0$f:=>FractionalFractional$f:=>FractionalFractional0$f:=>IntegralFractional$f:=>RealFloatFractional$f:=>(%%)Fractional$f:=>(%%)Fractional0 $f:=>(%%)Bits $f:=>BitsBits$f:=>BitsBits0$f:=>(%%)Bits0$f:=>(%%)Bits1$f:=>(%%)Bits2$f:=>(%%)Bits3$f:=>(%%)Integral$f:=>IntegralIntegral$f:=>IntegralIntegral0$f:=>(%%)Integral0$f:=>(%%)Integral1$f:=>(%%)Integral2 $f:=>(%%)Real $f:=>RealReal$f:=>RealReal0$f:=>(%%)Real0$f:=>IntegralReal$f:=>(%%)Real1$f:=>(%%)Real2$f:=>(%%)Real3$f:=>(%%)Real4 $f:=>(%%)Num $f:=>NumNum $f:=>NumNum0 $f:=>(%%)Num0$f:=>IntegralNum$f:=>RealFloatNum $f:=>(%%)Num1 $f:=>(%%)Num2 $f:=>(%%)Num3 $f:=>(%%)Num4$f:=>BoundedBounded$f:=>BoundedBounded0$f:=>(%%)Bounded$f:=>(%,%)Bounded$f:=>(%%)Bounded0$f:=>(%%)Bounded1$f:=>(%%)Bounded2$f:=>(%%)Bounded3$f:=>(%%)Bounded4 $f:=>(%%)Enum $f:=>EnumEnum$f:=>EnumEnum0$f:=>(%%)Enum0$f:=>IntegralEnum$f:=>(%%)Enum1$f:=>(%%)Enum2$f:=>(%%)Enum3$f:=>(%%)Enum4$f:=>(%%)Enum5$f:=>(%%)Enum6$f:=>(%%)Enum7$f:=>(%%)Enum8 $f:=>(%%)Read $f:=>ReadRead$f:=>ReadRead0$f:=>(%%)Read0$f:=>(%,%)Read$f:=>(%,%)Read0$f:=>(%,%)Read1$f:=>ReadRead1$f:=>ReadRead2$f:=>ReadRead3$f:=>(%%)Read1$f:=>(%%)Read2$f:=>(%%)Read3$f:=>(%%)Read4$f:=>(%%)Read5 $f:=>(%%)Show $f:=>ShowShow$f:=>ShowShow0$f:=>(%%)Show0$f:=>(%%)Show1$f:=>(%%)Show2$f:=>(%,%)Show$f:=>(%,%)Show0$f:=>(%,%)Show1$f:=>ShowShow1$f:=>ShowShow2$f:=>ShowShow3$f:=>(%%)Show3$f:=>(%%)Show4$f:=>(%%)Show5$f:=>(%%)Show6$f:=>(%%)Show7 $f:=>(%%)Ord $f:=>OrdOrd $f:=>OrdOrd0 $f:=>(%%)Ord0 $f:=>(%%)Ord1 $f:=>(%%)Ord2$f:=>IntegralOrd $f:=>(%,%)Ord$f:=>(%,%)Ord0 $f:=>OrdOrd1 $f:=>OrdOrd2 $f:=>(%%)Ord3 $f:=>(%%)Ord4 $f:=>(%%)Ord5 $f:=>(%%)Ord6 $f:=>(%%)Ord7 $f:=>(%%)Ord8 $f:=>(%%)Ord9 $f:=>(%%)Eq $f:=>EqEq $f:=>EqEq0 $f:=>(%%)Eq0 $f:=>(%%)Eq1 $f:=>(%%)Eq2 $f:=>(%,%)Eq $f:=>(%,%)Eq0 $f:=>EqEq1 $f:=>EqEq2 $f:=>EqEq3 $f:=>EqEq4 $f:=>(%%)Eq3 $f:=>(%%)Eq4 $f:=>(%%)Eq5 $f:=>(%%)Eq6 $f:=>(%%)Eq7 $f:=>(%%)Eq8 $f:=>(%%)(%%) $f:=>(%%):=>$f:=>(%%)Class$fClass(%%):=> $fReadDict $fShowDict $fOrdDict$fEqDict Deferrable deferEitherUnsatisfiedConstraintdeferdeferreddefer_ deferEither_ $fExceptionUnsatisfiedConstraint$fDeferrable(%,,%)$fDeferrable(%,%)$fDeferrable~~ $fDeferrable~$fDeferrable(%%)$fShowUnsatisfiedConstraintInstVinstVForallVForall1ForallTForallFForallinstinstFinstTinst1forall $fForall_kp$fComposeCk2k1pfa$fForallFk2k1pf $fRk3k1k2ptab $fQk3k1k2pta$fForallTk4k1k2k3pt $fInstV->pc $fInstV->pc0 $fInstVTYPEpc $fForallV_kpLifting2lifting2Liftinglifting$fLifting->MonadStateContT$fLifting->MonadStateErrorT$fLifting->MonadStateExceptT$fLifting->MonadStateReaderT$fLifting->MonadStateWriterT$fLifting->MonadStateWriterT0$fLifting->MonadStateIdentityT$fLifting->MonadStateListT$fLifting->MonadStateMaybeT$fLifting->MonadReaderContT$fLifting->MonadReaderErrorT$fLifting->MonadReaderExceptT$fLifting->MonadReaderStateT$fLifting->MonadReaderStateT0$fLifting->MonadReaderWriterT$fLifting->MonadReaderWriterT0$fLifting->MonadReaderIdentityT$fLifting->MonadReaderListT$fLifting->MonadReaderMaybeT$fLifting->MonadRWSExceptT$fLifting->MonadRWSErrorT$fLifting->MonadRWSIdentityT$fLifting->MonadRWSMaybeT$fLifting->MonadErrorRWST$fLifting->MonadErrorRWST0$fLifting->MonadErrorReaderT$fLifting->MonadErrorStateT$fLifting->MonadErrorStateT0$fLifting->MonadErrorWriterT$fLifting->MonadErrorWriterT0$fLifting->MonadErrorIdentityT$fLifting->MonadErrorListT$fLifting->MonadErrorMaybeT$fLifting->MonadContRWST$fLifting->MonadContRWST0$fLifting->MonadContReaderT$fLifting->MonadContStateT$fLifting->MonadContStateT0$fLifting->MonadContExceptT$fLifting->MonadContErrorT$fLifting->MonadContWriterT$fLifting->MonadContWriterT0$fLifting->MonadContIdentityT$fLifting->MonadContListT$fLifting->MonadContMaybeT$fLiftingTYPEReadIdentity$fLiftingTYPEShowIdentity$fLiftingTYPEOrdIdentity$fLiftingTYPEEqIdentity$fLiftingTYPEEqLift$fLiftingTYPEOrdLift$fLiftingTYPEReadLift$fLiftingTYPEShowLift$fLifting->Eq1Lift$fLifting->Ord1Lift$fLifting->Read1Lift$fLifting->Show1Lift$fLifting->AlternativeLift$fLifting->ApplicativeLift$fLifting->TraversableLift$fLifting->FoldableLift$fLifting->FunctorLift$fLiftingTYPEEqBackwards$fLiftingTYPEOrdBackwards$fLiftingTYPEReadBackwards$fLiftingTYPEShowBackwards$fLifting->Eq1Backwards$fLifting->Ord1Backwards$fLifting->Read1Backwards$fLifting->Show1Backwards$fLifting->AlternativeBackwards$fLifting->ApplicativeBackwards$fLifting->TraversableBackwards$fLifting->FoldableBackwards$fLifting->FunctorBackwards$fLiftingTYPEEqReverse$fLiftingTYPEOrdReverse$fLiftingTYPEReadReverse$fLiftingTYPEShowReverse$fLifting->Eq1Reverse$fLifting->Ord1Reverse$fLifting->Read1Reverse$fLifting->Show1Reverse$fLifting->TraversableReverse$fLifting->FoldableReverse$fLifting->AlternativeReverse$fLifting->ApplicativeReverse$fLifting->FunctorReverse$fLiftingTYPEEqMaybeT$fLiftingTYPEOrdMaybeT$fLiftingTYPEReadMaybeT$fLiftingTYPEShowMaybeT$fLifting->Eq1MaybeT$fLifting->Ord1MaybeT$fLifting->Read1MaybeT$fLifting->Show1MaybeT$fLifting->MonadIOMaybeT$fLifting->TraversableMaybeT$fLifting->FoldableMaybeT$fLifting->MonadPlusMaybeT$fLifting->MonadMaybeT$fLifting->FunctorMaybeT$fLiftingTYPEEqListT$fLiftingTYPEOrdListT$fLiftingTYPEReadListT$fLiftingTYPEShowListT$fLifting->Eq1ListT$fLifting->Ord1ListT$fLifting->Read1ListT$fLifting->Show1ListT$fLifting->MonadIOListT$fLifting->TraversableListT$fLifting->FoldableListT$fLifting->MonadPlusListT$fLifting->MonadListT$fLifting->AlternativeListT$fLifting->ApplicativeListT$fLifting->FunctorListT$fLiftingTYPEEqIdentityT$fLiftingTYPEOrdIdentityT$fLiftingTYPEReadIdentityT$fLiftingTYPEShowIdentityT$fLifting->Eq1IdentityT$fLifting->Ord1IdentityT$fLifting->Read1IdentityT$fLifting->Show1IdentityT$fLifting->MonadIOIdentityT$fLifting->TraversableIdentityT$fLifting->FoldableIdentityT$fLifting->MonadFixIdentityT$fLifting->MonadPlusIdentityT$fLifting->MonadIdentityT$fLifting->AlternativeIdentityT$fLifting->ApplicativeIdentityT$fLifting->FunctorIdentityT$fLifting->MonadIOContT$fLifting->MonadContT$fLifting->ApplicativeContT$fLifting->FunctorContT$fLiftingTYPEReadWriterT$fLiftingTYPEOrdWriterT$fLiftingTYPEEqWriterT$fLiftingTYPEShowWriterT$fLifting->Read1WriterT$fLifting->Ord1WriterT$fLifting->Eq1WriterT$fLifting->Show1WriterT$fLifting->MonadIOWriterT$fLifting->TraversableWriterT$fLifting->FoldableWriterT$fLifting->MonadPlusWriterT$fLifting->MonadFixWriterT$fLifting->MonadWriterT$fLifting->AlternativeWriterT$fLifting->ApplicativeWriterT$fLifting->FunctorWriterT$fLiftingTYPEReadWriterT0$fLiftingTYPEOrdWriterT0$fLiftingTYPEEqWriterT0$fLiftingTYPEShowWriterT0$fLifting->Read1WriterT0$fLifting->Ord1WriterT0$fLifting->Eq1WriterT0$fLifting->Show1WriterT0$fLifting->MonadIOWriterT0$fLifting->TraversableWriterT0$fLifting->FoldableWriterT0$fLifting->MonadPlusWriterT0$fLifting->MonadFixWriterT0$fLifting->MonadWriterT0$fLifting->AlternativeWriterT0$fLifting->ApplicativeWriterT0$fLifting->FunctorWriterT0$fLiftingTYPEReadExceptT$fLiftingTYPEOrdExceptT$fLiftingTYPEEqExceptT$fLiftingTYPEShowExceptT$fLifting->Read1ExceptT$fLifting->Ord1ExceptT$fLifting->Eq1ExceptT$fLifting->Show1ExceptT$fLifting->MonadIOExceptT$fLifting->MonadPlusExceptT$fLifting->MonadFixExceptT$fLifting->MonadExceptT$fLifting->TraversableExceptT$fLifting->FoldableExceptT$fLifting->FunctorExceptT$fLiftingTYPEReadErrorT$fLiftingTYPEOrdErrorT$fLiftingTYPEEqErrorT$fLiftingTYPEShowErrorT$fLifting->Read1ErrorT$fLifting->Ord1ErrorT$fLifting->Eq1ErrorT$fLifting->Show1ErrorT$fLifting->MonadIOErrorT$fLifting->MonadPlusErrorT$fLifting->MonadFixErrorT$fLifting->MonadErrorT$fLifting->TraversableErrorT$fLifting->FoldableErrorT$fLifting->FunctorErrorT$fLifting->MonadIOReaderT$fLifting->MonadFixReaderT$fLifting->MonadPlusReaderT$fLifting->MonadReaderT$fLifting->AlternativeReaderT$fLifting->ApplicativeReaderT$fLifting->FunctorReaderT$fLifting->MonadIORWST$fLifting->MonadPlusRWST$fLifting->MonadFixRWST$fLifting->MonadRWST$fLifting->FunctorRWST$fLifting->MonadIORWST0$fLifting->MonadPlusRWST0$fLifting->MonadFixRWST0$fLifting->MonadRWST0$fLifting->FunctorRWST0$fLifting->MonadPlusStateT$fLifting->MonadIOStateT$fLifting->MonadFixStateT$fLifting->MonadStateT$fLifting->FunctorStateT$fLifting->MonadPlusStateT0$fLifting->MonadIOStateT0$fLifting->MonadFixStateT0$fLifting->MonadStateT0$fLifting->FunctorStateT0$fLiftingTYPEShowSum$fLiftingTYPEReadSum$fLiftingTYPEOrdSum$fLiftingTYPEEqSum$fLifting->Read1Sum$fLifting->Ord1Sum$fLifting->Eq1Sum$fLifting->Show1Sum$fLifting->TraversableSum$fLifting->FoldableSum$fLifting->FunctorSum$fLiftingTYPEShowProduct$fLiftingTYPEReadProduct$fLiftingTYPEOrdProduct$fLiftingTYPEEqProduct$fLifting->Read1Product$fLifting->Ord1Product$fLifting->Eq1Product$fLifting->Show1Product$fLifting->MonadPlusProduct$fLifting->MonadFixProduct$fLifting->MonadProduct$fLifting->AlternativeProduct$fLifting->ApplicativeProduct$fLifting->TraversableProduct$fLifting->FoldableProduct$fLifting->FunctorProduct$fLiftingTYPEShowCompose$fLiftingTYPEReadCompose$fLiftingTYPEOrdCompose$fLiftingTYPEEqCompose$fLifting->Read1Compose$fLifting->Ord1Compose$fLifting->Eq1Compose$fLifting->Show1Compose$fLifting->AlternativeCompose$fLifting->ApplicativeCompose$fLifting->TraversableCompose$fLifting->FoldableCompose$fLifting->FunctorCompose$fLiftingTYPEIx(,)$fLiftingTYPEBounded(,)$fLiftingTYPEMonoid(,)$fLiftingTYPESemigroup(,)$fLiftingTYPENFData(,)$fLiftingTYPEBinary(,)$fLiftingTYPEHashable(,)$fLiftingTYPERead(,)$fLiftingTYPEShow(,)$fLiftingTYPEOrd(,)$fLiftingTYPEEq(,)$fLiftingTYPENFDataEither$fLiftingTYPEBinaryEither$fLiftingTYPEHashableEither$fLiftingTYPEReadEither$fLiftingTYPEShowEither$fLiftingTYPEOrdEither$fLiftingTYPEEqEither$fLiftingTYPEMonoid->$fLiftingTYPESemigroup->$fLiftingTYPEShowComplex$fLiftingTYPEReadComplex$fLiftingTYPEEqComplex$fLiftingTYPEEqRatio$fLiftingTYPEMonoidMaybe$fLiftingTYPESemigroupMaybe$fLiftingTYPENFDataMaybe$fLiftingTYPEBinaryMaybe$fLiftingTYPEHashableMaybe$fLiftingTYPEReadMaybe$fLiftingTYPEShowMaybe$fLiftingTYPEOrdMaybe$fLiftingTYPEEqMaybe$fLiftingTYPENFData[]$fLiftingTYPEBinary[]$fLiftingTYPEHashable[]$fLiftingTYPERead[]$fLiftingTYPEShow[]$fLiftingTYPEOrd[]$fLiftingTYPEEq[]$fLifting2->Read1Sum$fLifting2->Ord1Sum$fLifting2->Eq1Sum$fLifting2->Show1Sum$fLifting2->TraversableSum$fLifting2->FoldableSum$fLifting2->FunctorSum$fLifting2->Read1Product$fLifting2->Ord1Product$fLifting2->Eq1Product$fLifting2->Show1Product$fLifting2->MonadFixProduct$fLifting2->MonadPlusProduct$fLifting2->MonadProduct$fLifting2->AlternativeProduct$fLifting2->ApplicativeProduct$fLifting2->TraversableProduct$fLifting2->FoldableProduct$fLifting2->FunctorProduct$fLifting2->AlternativeCompose$fLifting2->ApplicativeCompose$fLifting2->TraversableCompose$fLifting2->FoldableCompose$fLifting2->FunctorCompose$fLifting2TYPEIx(,)$fLifting2TYPEBounded(,)$fLifting2TYPEMonoid(,)$fLifting2TYPESemigroup(,)$fLifting2TYPENFData(,)$fLifting2TYPEBinary(,)$fLifting2TYPEHashable(,)$fLifting2TYPERead(,)$fLifting2TYPEShow(,)$fLifting2TYPEOrd(,)$fLifting2TYPEEq(,)$fLifting2TYPENFDataEither$fLifting2TYPEBinaryEither$fLifting2TYPEHashableEither$fLifting2TYPEReadEither$fLifting2TYPEShowEither$fLifting2TYPEOrdEither$fLifting2TYPEEqEitherDividesLcmGcdMaxMineqLe dividesGcd dividesLcm gcdCommutes lcmCommutesgcdZerogcdOnelcmZerolcmOnegcdNatlcmNatplusNatminusNatminNatmaxNattimesNatpowNatdivNatmodNatplusZero minusZero timesZerotimesOneminZeromaxZeropowZeroleZerozeroLeplusMinusInverse1plusMinusInverse2plusMinusInverse3 plusMonotone1 plusMonotone2 powMonotone1 powMonotone2 divMonotone1 divMonotone2timesMonotone1timesMonotone2 minMonotone1 minMonotone2 maxMonotone1 maxMonotone2powOneplusModtimesModmodBound euclideanNat plusCommutes timesCommutes minCommutes maxCommutesplusAssociatestimesAssociates minAssociates maxAssociates gcdAssociates lcmAssociatesminIsIdempotentmaxIsIdempotentgcdIsIdempotentlcmIsIdempotentminDistributesOverPlusminDistributesOverTimesminDistributesOverPow1minDistributesOverPow2minDistributesOverMaxmaxDistributesOverPlusmaxDistributesOverTimesmaxDistributesOverPow1maxDistributesOverPow2maxDistributesOverMinplusDistributesOverTimestimesDistributesOverPowtimesDistributesOverGcdtimesDistributesOverLcmplusIsCancellativetimesIsCancellativegcdDistributesOverLcmlcmDistributesOverGcd dividesPlus dividesTimes dividesMin dividesMax dividesDef dividesPowtimesDivleIdleEqleTransLengthDropTake++ appendSymbol appendUnit1 appendUnit2appendAssociates takeSymbol dropSymboltakeAppendDrop lengthSymbol takeLengthtake0 takeEmpty dropLengthdrop0 dropEmpty lengthTake lengthDropdropDroptakeTakeunsafeCoerceConstraint unsafeDeriveunsafeUnderiveunsafeApplicativeunsafeAlternative GHC.ClassesEqOrdControl.CategoryCategoryInt.id Data.ProxyProxy