!ϱZ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY(c) Justin Le 2018BSD3 justin@jle.im experimental non-portableNone+,-7;<=FQSTV]i% decidable p is the predicate that p is not true. decidable Implicatons p  q can be lifted "through" a  into an f p  f q. decidable Implicatons p  q can be lifted "through" a  into an f p  f q.  decidableIf  T :: k -> Z is a type constructor, then   T is a constraint that T8 is "decidable", in that you have a canonical function: proveTC :: Sing a -> T a Is essentially  , except with type constructors k -> Z6 instead of matchable type-level functions (that are k ~> Z).jMostly is in this library for compatiblity with "traditional" predicates that are GADT type constructors.  decidableIf  T :: k -> Z is a type constructor, then   T is a constraint that T8 is "decidable", in that you have a canonical function: decideTC :: Sing a ->  (T a) Is essentially , except with type constructors k -> Z5 instead of matchable type-level functions (that are k ~> Z).jMostly is in this library for compatiblity with "traditional" predicates that are GADT type constructors.  decidable  p is a constraint that p can be disproven.  decidableAA typeclass for provable predicates (constructivist tautologies).,A predicate is provable if, given any input a, you can generate a proof of p @@ a<. Essentially, it means that a predicate is "always true".SThis typeclass associates a canonical proof function for every provable predicate.It confers two main advatnages: JThe proof function for every predicate is available via the same name We can write   instances for polymorphic predicate transformers (predicates parameterized on other predicates) easily, by refering to  ) instances of the transformed predicates.  decidable-The canonical proving function for predicate p. Note that   is ambiguously typed, so you always\ need to call by specifying the predicate you want to prove using TypeApplications syntax:   @MyPredicate  decidable%A typeclass for decidable predicates.-A predicate is decidable if, given any input a$, you can either prove or disprove p @@ a. A  (p @@ a)# is a data type that has a branch p @@ a and [ (p @@ a).WThis typeclass associates a canonical decision function for every decidable predicate.It confers two main advatnages: MThe decision function for every predicate is available via the same name We can write  instances for polymorphic predicate transformers (predicates parameterized on other predicates) easily, by refering to ) instances of the transformed predicates. decidable.The canonical decision function for predicate p. Note that  is ambiguously typed, so you always\ need to call by specifying the predicate you want to prove using TypeApplications syntax:  @MyPredicate  decidableThis is implication !, but only in a specific context h. decidable We say that p implies q (p  q ) if, given p  a, we can always prove q @@ a. decidable!A proving function for predicate p. See   for more information. decidableLike !, but only in a specific context h. decidableLike implication , but knowing p @@ a" can only let us decidably prove q  a is true or false. decidable"A decision function for predicate p. See  for more information. decidableA  p a is a value of type p @@ a- --- that is, it is a proof or witness that p is satisfied for a.It essentially turns a k ~> Z ("matchable"  k) /back into/ a k -> Z predicate. decidable%Pre-compose a function to a predicate  :: (k ~> j) ->  j -> Predicate k  decidableConvert a tradtional k ~> \ predicate into a .  :: (k ~> Bool) -> Predicate k  decidable a+ is a predicate that the input is equal to a.  :: k ->  k  decidableThe always-false predicateCould also be defined as ] Void&, but this defintion gives us a free  instance.  ::  k  decidableThe always-true predicate.  ::  k  decidableConvert a normal '->' type constructor into a .  :: (k -> Z) ->  k  decidable>A type-level predicate in Haskell. We say that the predicate P ::  k is true/satisfied by input x :: k" if there exists a value of type P @@ xD, and that it false/disproved if such a value cannot exist. (Where ^ is _S, the singleton library's type-level function application for mathcable functions)See   and H for more information on how to use, prove and decide these predicates. The kind k ~> Z is the kind of "matchable" type-level functions in Haskell. They are type-level functions that are encoded as dummy type constructors ("defunctionalization symbols") that can be decidedly "matched" on for things like typeclass instances.1There are two ways to define your own predicates: XUsing the predicate combinators and predicate transformers in this library and the  singletonsv library, which let you construct pre-made predicates and sometimes create predicates from other predicates.AManually creating a data type that acts as a matchable predicate.\For an example of the latter, we can create the "not p" predicate, which takes a predicate p5 as input and returns the negation of the predicate: {-- First, create the data type with the kind signature you want data Not :: Predicate k -> Predicate k -- Then, write the _N instance, to specify the type of the -- witnesses of that predicate instance _ (Not p) a = (p ^ a) -> Void See the source of Data.Type.Predicate and Data.Type.Predicate.Logic` for simple examples of hand-made predicates. For example, we have the always-true predicate : >data Evident :: Predicate k instance Apply Evident a = Sing a #And the "and" predicate combinator: Xdata (&&&) :: Predicate k -> Predicate k -> Predicate k instance Apply (p &&& q) a = (p ^ a, q ^ a) [Typically it is recommended to create predicates from the supplied predicate combinators (d can be used for any type constructor to turn it into a predicate, for instance) whenever possible.  decidable%The deciding/disproving function for   p.Must be called by applying the  to disprove:   @p ! decidable$The canonical deciding function for   t." decidable#The canonical proving function for   t.# decidableCompose two implications.$ decidableDecide Not p based on decisions of p.% decidable2Flip the contents of a decision. Turn a proof of a into a disproof of not-a.>Note that this is not reversible in general in Haskell. See  for a situation where it is.& decidableMap over the value inside a .' decidable Converts a  to a `$. Drop the witness of disproof of a , returning a if  (with the proof) and b if .( decidableDrop the witness of proof of a , returning b if  and a if  (with the disproof).) decidableBoolean test if a  is .* decidableBoolean test if a  is .+ decidableMHelper function for a common pattern of eliminating the disproved branch of  to certaintify the proof., decidableChange the target of a [( with a contravariant mapping function.,  !"#$%&'()*+,,$ "# !%&+'()*,1111(c) Justin Le 2018BSD3 justin@jle.im experimental non-portableNone+,-;<=FNQSTV]i%4 decidable+Two-way implication, or logical equivalence5 decidable5 p q is a constraint that p 4 q is  ; that is, you can prove that p is logically equivalent to q.6 decidable6 p q is a constraint that p 7 q is  ; that is, you can prove that p implies q.7 decidablep ==> q is true if q+ is provably true under the condition that p is true.8 decidablep 8 q is a predicate that either p and q are true, but not both.9 decidablecRight-biased "or". In proofs, prioritize a proof of the right side over a proof of the left side.: decidablebLeft-biased "or". In proofs, prioritize a proof of the left side over a proof of the right side.; decidablep ; q is a predicate that either p and q are true.< decidablep < q is a predicate that both p and q are true.= decidableDecide p < q based on decisions of p and q.> decidableDecide p ; q based on decisions of p and q.Prefers p over q.? decidableDecide p 8 q based on decisions of p and q.@ decidableIf q is provable, then so is p 7 q.$This can be used as an easy plug-in   instance for p 7 q if q is  : Hinstance Provable (p ==> MyPred) where prove = proveImplies @MyPred UThis instance isn't provided polymorphically because of overlapping instance issues.A decidableFrom   a<, you can prove anything. Essentially a lifted version of c.B decidable# can be proven from all predicates.C decidableWe cannot have both p and  p.D decidable)If p implies q, then not q implies not p.E decidableReverse direction of D. Only possible if q is ! on its own, without the help of p%, which makes this much less useful.F decidable+Logical double negation. Only possible if p is .G decidableIf p < q is true, then so is p.H decidableIf p < q is true, then so is q.I decidableIf p is true, then so is p ; q.J decidableIf q is true, then so is p ; q.M decidablePrefers p over q.N decidableO decidableP decidableQ decidableR decidableS decidableT decidableU decidableV decidableW decidableX decidableY decidableZ decidable#$456789:;<=>?@ABCDEFGHIJ$<=;>:98?7@645#ABCFDEGHIJ4171;2<3(c) Justin Le 2018BSD3 justin@jle.im experimental non-portableNone&',-.013456;=FQSTV]di7_ decidableXIndex into a disjoint union by providing an index into one of the two possible options.b decidable0Disjoint union of two Functors. Is the same as    and   , except with a singleton and meant to be used at the type level. Will be redundant if either of the above gets brought into the singletons library.INote that because this is a higher-kinded data constructor, there is no d instance; if you need e and f&, consider manually pattern matching. Note that g acts as an identity.e decidable>A pair of indices allows you to index into a nested structure.i decidablel lifted to the type levelj decidable&Compose two Functors. Is the same as   and  , except with a singleton and meant to be used at the type level. Will be redundant if either of the above gets brought into the singletons library.INote that because this is a higher-kinded data constructor, there is no d instance; if you need e and f, try going through k and l and  and . Note that h acts as an identity.m decidable&Trivially witness the item held in an h.o decidableThere are no items of type a in a g a.p decidableDTrivially witness an item in the second field of a type-level tuple.r decidable Witness an item in a type-level iU by either indicating that it is the "head", or by providing an index in the "tail".u decidable Test that an j is kv decidable Test that an j is lw decidable Witness an item in a type-level j j by proving the j is l.y decidable Test that a ` is b.z decidable Test that a ` is a.{ decidable Witness an item in a type-level ` by proving the ` is a.} decidable<Witness an item in a type-level list by providing its index. decidableA  f p is a predicate on a collection as that at least one a in as does not satisfy predicate p. decidableA  f p is a predicate on a collection as that no a in as satisfies predicate p. decidablePredicate that a given  as :: f k0 is not empty, and has at least one item in it. decidablePredicate that a given  as :: f k! is empty and has no items in it. decidable_Typeclass for a type-level container that you can quantify or lift type-level predicates over. decidable, but providing an . decidable, but providing an . decidable, but providing an . decidableAn  f p% is a predicate testing a collection  as :: f a for the fact that all items in as satisfy p=. Represents the "forall" quantifier over a given universe.This is mostly useful for its ,  , and / instances, which lets you lift predicates on p to predicates on  f p. decidableA  p as! is a witness that the predicate p a is true for all items a in the type-level collection as. decidableAn  f p% is a predicate testing a collection  as :: f a) for the fact that at least one item in as satisfies p=. Represents the "exists" quantifier over a given universe.This is mostly useful for its  and / instances, which lets you lift predicates on p to predicates on  f p. decidableA  p as* is a witness that, for at least one item a in the type-level collection as, the predicate p a is true. decidable f as# is a predicate that a given input a is a member of collection as. decidableCA witness for membership of a given item in a type-level collection decidableLifts a predicate p on an individual a( into a predicate that on a collection as that is true if and only if any item in as# satisfies the original predicate.&That is, it turns a predicate of kind  k ~> Type into a predicate of kind  f k ~> Type.-Essentially tests existential quantification. decidableLifts a predicate p on an individual a( into a predicate that on a collection as that is true if and only if all items in as# satisfies the original predicate.&That is, it turns a predicate of kind  k ~> Type into a predicate of kind  f k ~> Type.+Essentially tests universal quantification. decidableIf p a is true for all values a in as# under some (Applicative) context h, then you can create an  p as! under that Applicative context h.Can be useful with h. (which is basically unwrapping and wrapping  ), or with `U (which can express predicates that are either provably true or not provably false).`In practice, this can be used to iterate and traverse and sequence actions over all "items" in as. decidable, but providing an . decidableIf p a is true for all values a in as, then we have  p as). Basically witnesses the definition of . decidable5Extract the item from the container witnessed by the m decidableSplit a  as into a proof that all a in as exist. decidable:Automatically generate a witness for a member, if possible decidable but with access to the index. decidableA n over all items in a collection. decidableSingletonized witness for i decidableTurn a composition of  into an  of a composition. decidableTurn an ( of a composition into a composition of . decidableTurn a composition of  into an  of a composition. decidableTurn an ( of a composition into a composition of . decidableTurn an  of f into an  of f b g. decidableTurn an  of g into an  of f b g. decidableTurn an  of f b g into an  of f. decidableTurn an  of f b g into an  of g. decidableTurn an  of f into an  of f b g. decidableTurn an  of g into an  of f b g. decidableTurn an  of f b g into an  of f. decidableTurn an  of f b g into an  of g. decidableThe null universe decidablePThe single-pointed universe. Note that this instance is really only usable in singletons-2.5 and higher (so GHC 8.6).  decidablepredicate on value decidablepredicate on collection decidablepredicate on value decidablepredicate on collection decidablepredicate on value in context decidable"predicate on collection in context decidablepredicate on value decidablepredicate on collection decidablepredicate on value decidablepredicate on collection decidablepredicate on value in context decidable"predicate on collection in context decidablealways-true predicate on value decidable#always-true predicate on collection decidablealways-true predicate on value decidable#always-true predicate on collection decidableWitness decidable CollectionO_`abcdefghijklmnopqrstuvwxyz{|}~O}~{|wxrstpqomnef_`azyvujklibcdhg(c) Justin Le 2018BSD3 justin@jle.im experimental non-portableNone ,-FQSTV]i: decidable, but providing an . decidableLifts a predicate p on an individual a( into a predicate that on a collection as that is true if and only if no item in as# satisfies the original predicate.&That is, it turns a predicate of kind  k ~> Type into a predicate of kind  f k ~> Type. decidable, but providing an . decidableIf there exists an a s.t. p a , and if p implies q, then there must exist an a s.t. q a. decidable, but providing an . decidable If for all a we have p a , and if p implies q, then for all a we must also have p a. decidable, but providing an . decidableIf p implies q under some context h, and if there exists some a such that p a, then there must exist some a such that p q under that context h.h might be something like, say, `F, to give predicate that is either provably true or unprovably false.-Note that it is not possible to do this with p a ->  (q a). This is if the p a ->  (q a)< implication is false, there it doesn't mean that there is no a such that q a), necessarily. There could have been an a where p does not hold, but q does. decidable, but providing an . decidableIf p implies q under some context h, and if we have p a for all a, then we must have q a for all a under context h. decidable, but providing an . decidable If we have p a for all a, and p a can be used to test for q a, then we can test all as for q a. decidable5It is impossible for any value in a collection to be . decidableIf any a in as does not satisfy p, then not all a in as satisfy p. decidable If not all a in as satisfy p#, then there must be at least one a in as that does not satisfy p . Requires  p# in order to locate that specific a. decidableIf p is false for all a in as , then no a in as satisfies p. decidableIf no a in as satisfies p, then p is false for all a in as . Requires  p# to interrogate the input disproof.  decidablepredicate on value decidablepredicate on collection decidablepredicate on value decidablepredicate on collection decidable implication decidable implication decidableimplication in context decidableimplication in context decidableimplication in context decidableimplication in context decidabledecidable implication""(c) Justin Le 2018BSD3 justin@jle.im experimental non-portableNone&'+,-;<=FSTV]iq decidableConjunction on two s, with appropriate  and  instances. decidableDisjunction on two s, with appropriate 5 instance. Priority is given to the left predicate. decidable f$ takes a parmaeterized predicate on k (testing for a v1) and turns it into a parameterized predicate on f k (testing for a v). It "lifts" the domain into f.An  f p as# is a predicate taking an argument a and testing if p a ::  k is satisfied for any item in  as :: f k.A  k v tests if a k can create some v. The resulting  (f k) v tests if any k in f k can create some v. decidableA  (f k) k. Parameterized on an  as :: f k8, returns a predicate that is true if there exists any a :: k in as. Essentially . decidableA constraint that a  k v/ s "selectable". It means that for any input x :: k, we can always find a y :: v that satisfies  P x @@ y. We can "select" that y, no matter what. decidableA constraint that a  k v0 is "searchable". It means that for any input x :: k/, we can prove or disprove that there exists a y :: v that satisfies P x @@ y. We can "search" for that y,, and prove that it can or cannot be found. decidablePre-compose a function to a . Is essentially o (p)T, but unfortunately defunctionalization doesn't work too well with that definition. decidable Promote a  v to a  k v, ignoring the k input. decidableFlip the arguments of a . decidableDConvert a parameterized predicate into a predicate on the parameter.A  p is a predicate on p ::  k v that tests a k for the fact that there  cannot exist a v where  k v is satisfied. That is,  P @@ x is satisfied if no y :: v can exist where P x @@ y is satisfied.!For some context, an instance of   ( P), where P ::  k v, means that for any input x :: k, we can always reject any y :: v that claims to satisfy P x @@ y.5In the language of quantifiers, it means that forall x :: k, there does not exist a y :: v such that P x @@ y.For an instance of  ( P), it means that for all x :: k@, we can prove or disprove the fact that there does not exist a y :: v such that P x @@ y. decidableDConvert a parameterized predicate into a predicate on the parameter.A  p is a predicate on p ::  k v that tests a k# for the fact that there exists a v where  k v is satisfied.$Intended as the basic interface for , since it turns a  into a normal , which can have  and   instances.!For some context, an instance of   ( P), where P ::  k v, means that for any input x :: k, we can always find a y :: v such that we have P x @@ y.5In the language of quantifiers, it means that forall x :: k, there exists a y :: v such that P x @@ y.For an instance of  ( P), it means that for all x :: k8, we can prove or disprove the fact that there exists a y :: v such that P x @@ y. decidable A parameterized predicate. See  for more information. decidable$The deciding/searching function for  p.Must be called by applying the :  @p  decidable#The proving/selecting function for  p.Must be called by applying the :  @p  decidable f is basically  ( f). decidable f is basically  ( f).(c) Justin Le 2018BSD3 justin@jle.im experimental non-portableNone+,-;<=>?FSTV]di  decidableAn   p a constraint means that p @@ a. can be proven to not be true at compiletime.  decidableHelper class for deriving  instances for  predicates; each C instance is expected to implement these if possible, to get free  instaces for their  predicates.Also helps for   predicates and    predicates.  decidable Generate an ) for a given predicate over all items in as. decidableTypeclass representing s pointing to an a :: kA that can be generated automatically from type-level collection  as :: f k.If GHC knows both the type-level collection and the element you want to find at compile-time, this instance should allow it to find it. Used to help in the instance of  for the  predicate.Example usage: BautoElem :: Index '[1,6,2,3] 2 -- IS (IS IZ) -- third spot And when used with : auto _ $(In [] '[1,6,2,3]) @2 -- IS (IS IZ)  decidable Generate the  pointing to the a ::  in a type-level collection  as :: f k. decidable9Helper "predicate transformer" that gives you an instant  for any   instance.$For example, say you have predicate P that you know is  , and you wish to generate a P @@ x, for some specific x) you know at compile-time. You can use:  _ (AutoProvable P) @x  to obtain a P @@ x.& is essentially the identity function. decidable/Automatically generate a witness for predicate p applied to input a.,Mostly useful for situations where you know a) at compile-time, so you can just write F directly in your source code. The choice is intended to mirror the auto! keyword in languages like Idris.Very close in nature to the Known typeclass in the type-combinators library.^Admittedly this interface is a bit clunky and ad-hoc; at this point you can just try writing  in your code and praying that it works. You always have the option, of course, to just manually write proofs. If you have any inference rules to suggest, feel free to submit a PR!An important limitation of } is the Haskell type system prevents "either-or" constraints; this could potentially be implemented using compiler plugins.JOne consequence of this is that it is impossible to automatically derive  f p and  ( f p).0For these, the compiler needs help; you can use  and  for these situations. decidable)Have the compiler generate a witness for p @@ a.-Must be called using type application syntax:  _ p @a  decidable Disprove p @@ a at compiletime. autoNot _ p  a :: Not p @ a  decidableHelper function to generate an  f p! if you can pick out a specific a in as1 where the predicate is provable at compile-time.7This is used to get around a fundamental limitation of  as a Haskell typeclass. decidableHelper function to generate a  ( f p)! if you can pick out a specific a in as4 where the predicate is disprovable at compile-time.7This is used to get around a fundamental limitation of  as a Haskell typeclass. decidable decidable decidable decidable decidable decidable  decidable! decidable" decidable# decidable' decidable. decidable5 decidable6 decidable7 decidableE decidable        (c) Justin Le 2018BSD3 justin@jle.im experimental non-portableNone ,-FQSTVi F decidableA F f p8 is a predicate that some decidable subset of an input as is true.G decidableA G f p  as describes a  decidable" subset of type-level collection as.J decidable Create a F from a predicate.K decidableTurn a F into a list (or any q) of satisfied predicates.'List is meant to include no duplicates.L decidable Restrict a F9 to a single (arbitrary) member, or fail if none exists.M decidableConstruct an empty subset.N decidableConstruct a full subsetO decidableTest if a subset is empty.P decidable0Combine two subsets based on a decision functionQ decidable0Combine two subsets based on a decision functionR decidableSubset intersectionS decidableSubset union (left-biased)T decidableSymmetric subset differenceU decidable;Test if a subset is equal to the entire original collectionV decidableW, but providing an .W decidableMMap a bidirectional implication over a subset described by that implication.HImplication needs to be bidirectional, or otherwise we can't produce a  decidable subset as a result.FGHIJKLMNOPQRSTUVWFGHIJRSTQPWVKLUOMNSaferstuvwxyz !"#$%&'()**+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrs tuvwxyz{|}~DF      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNNOPQRSTUVWXYZ[\]^_`abc`adefghijkijlijminopqristiuvijwixyixzix{|i}~ijijij(decidable-0.1.3.0-BDXVxj9RWVb9m5DXVh1hQkData.Type.PredicateData.Type.UniverseData.Type.Predicate.Logic"Data.Type.Predicate.QuantificationData.Type.Predicate.ParamData.Type.Predicate.AutoData.Type.Universe.SubsetdoubleNegationData.Functor.SumSum GHC.Generics:+:Data.Functor.ComposeCompose:.:Paths_decidable'singletons-2.4.1-CPkrVyNL0Sy7pQw5p6j80uData.Singletons.Decide DisprovedProvedDecisionData.Singletons.InternalSingNotTFunctortmapDFunctordmap ProvableTC DecidableTC DisprovableProvableprove Decidabledecide-->#-->Prove-?>#-?>DecideWitgetWitPMapBoolPredEqualTo ImpossibleEvidentTyPred PredicatedisprovedecideTCproveTCcompImpl decideNot flipDecision mapDecisionforgetDisproof forgetProofisProved isDisproved elimDisproof mapRefuted$fProvablek1.@#@$$$$fProvablek1TyCon$fDecidablek1.@#@$$$$fDecidablek1TyCon$fDecidablekTyCon$fDecidablek1Not$fProvablek1Not<==>EquivImplies==>^^^||^^|||||&&& decideAnddecideOr decideXor proveImplies explosionatomexcludedMiddlecontrapositivecontrapositive' projAndFst projAndSnd injOrLeft injOrRight$fProvablek1&&&$fDecidablek1&&&$fDecidablek1|||$fProvablek1==>$fProvablek1==>0$fDecidablek1==>$fProvablek1==>1$fDecidablek1==>0$fProvablek1==>2$fDecidablek1==>1$fProvablek1==>3$fDecidablek1==>2$fProvablek1==>4$fDecidablek1==>3$fProvablek1==>5$fDecidablek1==>4$fProvablek1==>6$fDecidablek1==>5$fProvablek1==>7$fDecidablek1==>6SumElemIInLIInRInLInRCompElem:? GetCompSym1 GetCompSym0GetCompCompgetComp IIdentityIIdIProxyISndNEIndexNEHeadNETailIsLeftIsRightIRight IsNothingIsJustIJustIndexIZISNotAllNoneNotNullNullUniverse idecideAny idecideAlligenAllAAllWitAll runWitAllAnyWitAnyInElemSym2ElemSym1ElemSym0ElemSInLSInRSComp decideAny decideAllgenAllAigenAllgenAllindexpickElem ifoldMapUni foldMapUnisGetCompanyCompcompAnyallCompcompAllanySumLanySumRsumLAnysumRAnyallSumLallSumRsumLAllsumRAll$fSingIIdentityIdentity$fSingKindIdentity+$fSuppressUnusedWarnings(->)RunIdentitySym0($fSuppressUnusedWarnings(->)IdentitySym0$fUniverseProxy$fDFunctork1fAll$fTFunctork1fAll$fTFunctork1fAny$fProvablefAll$fDecidablefAll$fDecidablefAny$fProvablef==>$fDecidablef==> $fUniverse[]$fUniverseMaybe$fDecidablekTyCon0$fUniverseEither$fDecidablekTyCon1$fUniverseNonEmpty$fDecidablekTyCon2 $fUniverse(,)$fDecidablekTyCon3$fUniverseIdentity$fDecidablekTyCon4$fSingI:.:Comp $fUniverse:.: $fUniverse:+: $fShow:.:$fEq:.:$fOrd:.: $fFunctor:.: $fFoldable:.: $fGeneric:.: $fShow:+:$fEq:+:$fOrd:+: $fFunctor:+: $fFoldable:+: $fGeneric:+:$fTraversable:+:$fTraversable:.:$fShowIIdentity $fShowIProxy $fShowISnd $fShowNEIndex $fShowIRight $fShowIJust $fShowIndex idecideNone decideNone ientailAny entailAny ientailAll entailAll ientailAnyF entailAnyF ientailAllF entailAllFidecideEntailAlldecideEntailAll anyImpossible anyNotNotAll notAllAnyNot allNotNone noneAllNotAndPOrPAnyMatchInP Selectable SearchablePPMapConstPPFlipPPNotFoundFound ParamPredsearchselect notNullInP inPNotNull$fProvablekFound$fDecidablekFound$fProvablef==>0$fDecidablef==>0$fDecidablefFound$fDecidablefFound0$fDecidablek1Found$fProvablek1Found$fDecidablek1Found0AutoNotAutoAllautoAllAutoElemautoElem AutoProvableAutoautoautoNotautoAny autoNotAll$fAutok.@#@$$$a $fAutokNota $fAutokFounda$fAuto:+:AnyInR$fAuto:+:AnyInL$fAutoIdentityAnyIdentity$fAutoProxyNotProxy$fAuto(,)Any(,)$fAutoNonEmptyAny:|$fAutoEitherNotLeft$fAutoEitherAnyRight$fAutoMaybeNotNothing$fAutoMaybeAnyJust $fAuto[]Any: $fAutok==>a $fAutok&&&a $fAutokTyCona $fAutokNota0$fAutokTyCona0$fAutokAutoProvablea$fAutokElemSym1a$fAutoElemk:+:InRb$fAutoElemk:+:InLa$fAutoElemkIdentityIdentitya$fAutoElemk(,)(,)a$fAutoElemkNonEmpty:|a$fAutoElemkNonEmpty:|a0$fAutoElemkEitherRighta$fAutoElemkMaybeJusta$fAutoElemk[]:a$fAutoElemk[]:a0 $fAutofNotas $fAutofNotas0 $fAutofAllas$fAutoAlla:+:pInR$fAutoAlla:+:pInL$fAutoAllaIdentitypIdentity$fAutoAllkProxypProxy$fAutoAllk(,)p(,)$fAutoAlla:.:pComp$fAutoAllaNonEmptyp:|$fAutoAllbEitherpRight$fAutoAllkEitherpLeft$fAutoAllaMaybepJust$fAutoAllkMaybepNothing$fAutoAlla[]p:$fAutoAllk[]p[] $fAutokNota1Subset WitSubset runWitSubset makeSubset subsetToList subsetToAny emptySubset fullSubset subsetToNone imergeSubset mergeSubset intersectionunionsymDiff subsetToAll imapSubset mapSubset$fProvablefSubset$fDecidablefSubsetghc-prim GHC.TypesTypeRefutedBoolData.Singletons.Prelude.Base ConstSym1@@ApplybaseGHC.BaseMaybeJustNothing Data.VoidabsurdSingKindfromSingtoSing Data.ProxyProxyData.Functor.IdentityIdentityNonEmpty Data.EitherEitherLeftRight splitSing Data.FoldablefoldMapflip. Alternativeversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName