3      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                               ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                              !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                     Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesSafe+DQRCopyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,9;<=DOQRT[b  The empty .     Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,9;<=DOQRT[b Each instance of  D provides a canonical construction of a type at a particular index..Useful for working with singleton-esque GADTs.    Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,69:;<=?DOQRT[b %$A general eliminator for entailment.Given a term of type t with an instance  Witness p q t and a term of type r that depends on  q#, we can reduce the Constraint to p.If p is C, i.e. the empty  (), then a Witness t) can completely discharge the Constraint q.(Reified evidence of  entailment.Given a term of p :- q, the Constraint q holds if p holds.Entailment of  s form a : id :: p :- p((.) :: (q :- r) -> (p :-> q) -> (p :- r)- A reified .1 Convert a % to a canonical reified .2 Convert a %# to a canonical reified entailment.<Constraint chaining under Maybe.GIf the constraint c> holds, there is a canonical construction for a term of type - c, viz. the constructor Wit.HA type equality a  b is a Witness that (a ~ b).IAn entailment p :- q is a Witness of q, given p.? !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOD !"#$%&'()*+,-./0123456789:;<=>?@ABCDE@-.+,()*O/%&'012#$3!"N ML456789:;KJIHGF<=>?@ABCDE/ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO 679 '1(400<0=0B4C4Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,69;<=?DOQRT[bgATake a natural transformation to a lifted natural transformation.An eliminator for a V type.Consider this function akin to a Monadic bind, except instead of binding into a Monad with a sequent function, we're binding into the existential quantification with a universal eliminator function.|It serves as an explicit delimiter in a program of where the type index may be used and depended on, and where it may not.hNB: the result type of the eliminating function may not refer to the universally quantified type index a.hPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~gPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~q}~~wxxyz{|tuuvqrrsnooplmjkhifgdebc`a^_\]Z[XYVWTURSPQ>PQRSTUVWXYZ[\]^_`abcdefghijklmnoopqrrstuuvwxxyz{|}~~y4z4{4|44444444444411111111111Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/9;<=?DOQRT[b4446Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/9;<=?DOQRT[bMap a list of (fs :: [k -> l]) over a single (a :: k), giving a list  (bs :: [l]).Map an  (f :: k -> l) over a type-level list  (as :: [k]), giving a list  (bs :: [l]).Takes a type-level list of s to a single , where ListC cs holds iff all elements of cs hold.Type-level list snoc.Appends two type-level lists.Type-level singleton list.%%%%454655None%&+,9:;<=?DOQRT[  Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,9;DOQRT[bMap over a type-level Maybe. Take a Maybe Constraint to a  Constraint.                    4454 Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,9;DOQRT[bMap over a type-level Maybe.Take a Maybe Constraint to a  Constraint. ! ! ! !4454 Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/23469;<=DOQRT[bQ"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqr."#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOQEFGrBCDqponml?@Akjih<=>gfedcbH9:;Ia`_J678^]K345\[ZL012YXM-./WVUN*+,TSRQPO()%&'"#$8"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqr Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/9;<=?DOQRT[b$$"66663 Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/9;<=DOQRT[b6Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/9;<=DOQRT[b)There are no possible values of the type Sum f . Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,9;DOQRT[b )There are no possible values of the type FSum a.<Decompose a non-empty FSum into either its head or its tail.Inject an element into an FSum.)Project an implicit index out of an FSum.EInject an element into an FSum with an explicitly specified Index.)Project an explicit index out of an FSum.Map over the single element in an FSum with a function that can handle any possible element, along with the element's index. NFun fact: Since there is exactly one element in an FSum, we don't need the Monoid instance! VAnother fun fact: Since there is exactly one element in an FSum, we require only a Functor instance on g, rather than  Applicative.                 Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/9;<=DOQRT[b !"#$%&'()**)('&%$#"!  !"#$%&'()*4422Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/9;<=DOQRT[b5Eliminator for 2 f.;(We can take a natural transformation of (forall x. f x -> g x)! to a natural transformation of  (forall mx. 2 f mx -> 2 g mx). 23456789:;2345 2345;:987623456789:;Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,9;<=DOQRT[bB~Construct a two element FProd. Since the precedence of (:>>) is higher than (:<<), we can conveniently write lists like: a :<< b :>> cWhich is identical to:a :<< b :<< c :<< CBuild a singleton FProd.D9snoc function. insert an element at the end of the FProd.G2Get all but the last element of a non-empty FProd.H*Get the last element of a non-empty FProd.I!Reverse the elements of an FProd.JAppend two FProds.K'Map over the head of a non-empty FProd.L'Map over the tail of a non-empty FProd.PEMap over all elements of an FProd with access to the element's index.QFFold over all elements of an FProd with access to the element's index.RJTraverse over all elements of an FProd with access to the element's index.SGA non-empty FProd is a Witness if both its head and tail are Witnesses.T"An empty FProd is a no-op Witness.WIf all f in fs are  Traversables, then FProd fs is a  Traversable.XIf all f in fs are Foldables, then FProd fs is a Foldable.YIf all f in fs are Functors, then FProd fs is a Functor.?@ABCDEFGHIJKLMNOPQRSTUVWXY?@ABCDEFGHIJKLMNOPQR?@ABCDEFGHIJKLMNOYXWPQRVUTS?@ABCDEFGHIJKLMNOPQRSTUVWXYA5B6D6Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/9;<=?DOQRT[bZ[\] Z[\]]\[ZZ[\]Z4[1\1Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/9;<=?DOQRT[bh/Convenient aliases for low-value Peano numbers.*^_`abcdefghijklmnopqrstuvwxyz{|}~*^_`abcdefghijklmnopqrstuvwxyz{}|~*{|}~zyxwvustrpqonmlkjihgfedcba`_^&^_`abcdefghijklmnopqrstuvwxyz{|}~i4j4k4l4o8r7u6Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/9;<=DOQRT[b4234114Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/9;<=?DOQRT[b A proof that |: is also a right identity for the addition of type-level s.A Nat n is a %- that there is a canonical construction for Nat n.If n is a canonical construction of Nat n,  n" is the canonical construction of  Nat (S n).$ is the canonical construction of a  Z.678Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/9;<=DOQRT[b   Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/9:;<=DOQRT[b8Gives the list of all members of the finite set of size n.There are no members of Fin Z.CMap a finite set to a lower finite set without one of its members.Take a  to an existentially quantified .A Fin n is a % that n >= 1. That is, w n is well defined. Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/9:;<=DOQRT[bAn IFin x y is a % that x >= 1. That is, w x is well defined. None%&+,9:;<=DOQRT[     Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/9:;<=DOQRT[b  A Prod of simple Haskell types.Cons onto a Tuple.{Construct a two element Prod. Since the precedence of (:>) is higher than (:<), we can conveniently write lists like: a :< b :> cWhich is identical to:a :< b :< c :< Build a singleton Prod.8snoc function. insert an element at the end of the list.1Get all but the last element of a non-empty Prod.)Get the last element of a non-empty Prod.Singleton Tuple.Snoc onto a Tuple.+     !"#$%&'()*+,-./01234     !"#$%+  43210/  !"#$.-,+*)( '&%)     !"#$%&'()*+,-./0123455666Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,9:;DOQRT[b 89:;<=>?@A   89:;<=>?@A 9:8;<=>?@A 89:;<=>?@A84Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/9;<=?DOQRT[bBCDEFGHIJKLMNOPQRSTUVWXYZ[\ BCDEFGHIJKLMDEF\[ZYXWVUTSRGHIJKLMBCQPONBCDEFGHIJKLMNOPQRSTUVWXYZ[\Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,9:;<=?DOQRT[b`abcdefghijklm `abdcefghbcdemfgh`alkji `abcdefghijklmd5Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone%&*+,/69:;<=DOQRT[b=nopqrstuvwxyz{|}~2nopqrstuvwxyz{|}~=stuwxrvyz{|}~opqn9nopqrstuvwxyz{|}~u4v4y5 None%&+,9:;<=DOQRT[!"#$%&$%'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPPQQRSTUVWXYZ[\]^_`abcdefghijklmnopqrssttuuvvwxyz{|}~                  ! " # $ % & ' ( )     * + , - . / 0 1 2 3 3 4 5 5 6 7 7 8 8 9 : : ; < < = > > ? @ @ A B B C D D E F F G H * I J J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrrsttuvwxyz{|}~^]      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[M\]^_`abcdeffghijklmnop qrstuvwxyz{|}~   Z                  $!"$$$%$%$%$%$%$%$%$%$%$%$$$$/type-combinators-0.2.4.0-B53x2yP6Ul69sucy1vcOtcType.Family.ConstraintData.Type.Index.TransType.Family.MonoidType.Class.KnownType.Class.WitnessType.Class.HigherType.Family.TupleType.Family.ListType.Family.EitherType.Family.MaybeData.Type.CombinatorData.Type.ConjunctionData.Type.Index Data.Type.SumData.Type.Sum.LiftedData.Type.DisjunctionData.Type.OptionData.Type.Product.LiftedType.Family.BoolType.Family.NatData.Type.Boolean Data.Type.NatData.Type.Length Data.Type.FinData.Type.Fin.IndexedData.Type.Nat.InequalityData.Type.ProductData.Type.SubsetData.Type.RemoveData.Type.DifferenceData.Type.VectorData.Type.Product.Envghc-prim GHC.Types ConstraintbaseData.Type.EqualityRefl:~:<>MemptyCompIffIffCFailØC $fCompkldca $fIffFalsetf $fIffTruetfKnownKnownCknown $fKnownk:~:b DecEqualitydecideEqualityDecProvenRefuted TestEquality1 testEquality1HoldsForallforall∨disjC∧conjC∘compCConstconstCFailsfailCWitnessWitnessC\\:-SubgetSubWit1WittransC// witnessedentailedabsurdCeitherCpureCcontraC toEqualitycommutefalsotopbottom//?//?+witMaybeqed impossibleexFalso=?==??=decCaseabsurd $fKnownkWit1a$fKnownConstraintWitc$fWitness(%%)~:~: $fWitnesspq:-$fWitness(%%)cWit1$fWitness(%%)cWit $f∧kfga $f∘klfga $fConstkcd$fCategoryConstraint:-SomeCSome3Some2Some IxBifunctor1ibimap1 Bifunctor1bimap1IxTraversable1 itraverse1 Traversable1 traverse1 IxFoldable1 ifoldMap1 Foldable1foldMap1 IxFunctor1imap1Functor1map1Read3 readsPrec3Read2 readsPrec2Read1 readsPrec1Show3 showsPrec3show3Show2 showsPrec2show2Show1 showsPrec1show1Ord3compare3<###>###<=###>=###Ord2compare2<##>##<=##>=##Ord1compare1<#>#<=#>=#Eq3eq3neq3Eq2eq2neq2Eq1eq1neq1=#==##==###=shows1shows2shows3reads1 readMaybe1reads2 readMaybe2reads3 readMaybe3some>>->->withSomeonSomemsome>>=-some2>>-->--> withSome2onSome2msome2>>=--some3>>--->---> withSome3onSome3msome3>>=---someC>>~msomeC>>=~$fEqSome<*><&><$>Thd3Snd3Fst3SndFst#fstCongsndCongfst3Congsnd3Congthd3Cong pairMapCongThds3Snds3Fsts3ZipSndsFstsListCLast'LastLastMInit'InitInitMTailTailMHeadHeadMReverse>:Concat++NullOnly:<ØnullCong nilNotCons appendCong concatCongsnocCong reverseConginitConglastCong listMapCongIxCompIxJustIxOrIxOrLIxOrRIxSecondIxFirstIxListIxHeadIxTailIxLiftLiftIixLiftIxEnvIxList'$fIxLiftEithermkIxOrRight$fIxLift(,)mkIxSecondp$fIxLift(,)mkIxFirstp FromRightFromLeft<|>IsRightIsLeftEitherCleftCong rightCong leftNotRighteitherFmapCongeitherPamfCong eitherApCong eitherAltCong fromLeftCong fromRightCongFromJust IsNothingMaybeC nothingCongnothingNotJust maybeFmapCong maybePamfCong maybeApCong maybeAltCong fromJustCongRRgetRRLLgetLLConjJoingetJoinUncur3 getUncur3Cur3getCur3UncurgetUncurCurgetCurFlipgetFlipCgetCIgetI:.:getCompComp1getComp1mapCflipTestEquality1mapFlipmapCurmapUncurmapCur3 mapUncur3mapJoin$fWitnesspqJoin $fKnownkJoina $fShow1kJoin $fOrd1kJoin $fEq1kJoin$fWitnessrsUncur3$fKnown(,,)Uncur3q$fRead1(,,)Uncur3$fWitnessqrCur3 $fKnownkCur3c$fWitnessrsUncur$fKnown(,)Uncurq$fRead1(,)Uncur$fWitnessqrCur $fKnownkCurb $fKnownkFlipa$fWitnesspqFlip$fTestEqualitykFlip$fNumC $fWitnesspqC $fRead1kC $fShow1kC$fOrd1kC$fEq1kC$fNumI $fWitnesspqI$fMonadI$fApplicativeI$fTestEquality1l(->):.:$fTestEqualityk:.:$fWitnesspq:.: $fShow1k:.: $fOrd1k:.: $fEq1k:.:$fFunctor1mkComp1$fEq:.:$fOrd:.: $fShow:.: $fRead:.:$fEqI$fOrdI$fShowI $fFunctorI $fFoldableI$fTraversableI$fEqC$fOrdC$fShowC$fReadC $fFunctorC $fFoldableC$fTraversableC$fEqFlip $fOrdFlip $fShowFlip $fReadFlip $fReadJoin $fShowJoin $fOrdJoin$fEqJoin $fReadUncur3 $fShowUncur3 $fOrdUncur3 $fEqUncur3 $fReadCur3 $fShowCur3 $fOrdCur3$fEqCur3 $fReadUncur $fShowUncur $fOrdUncur $fEqUncur $fReadCur $fShowCur$fOrdCur$fEqCur:*::&:fanFstfanSnd.&.fanFirst uncurryFancurryFanparFstparSnd uncurryParcurryPar_fst_snd$fWitness(%,%)(%,%):*:$fDecEquality(,):*:$fIxFunctor1k(,)IxSecond:*:$fBifunctor1(,)lk:*:$fTraversable1(,)k:*:$fFoldable1(,)k:*:$fFunctor1(,)k:*:$fKnown(,):*:p $fShow1(,):*: $fOrd1(,):*: $fEq1(,):*:$fWitness(%,%)(%,%):&:$fBifunctor1mmm:&:$fTraversable1ll:&:$fFoldable1ll:&:$fFunctor1ll:&: $fKnownk:&:a $fShow1k:&: $fOrd1k:&: $fEq1k:&: $fRead:*: $fShow:*:$fOrd:*:$fEq:*: $fRead:&: $fShow:&:$fOrd:&:$fEq:&:Every2every2EveryEveryCeveryElem elemIndex∈IndexIZIS elimIndexixNilonIxPred $fEvery2lac:y$fEvery2lkc[]y $fEveryac: $fEverykc[]$fKnownkIndexa$fWitness(%%)ElemIndex $fElemk:a $fElemk:a0$fTestEqualitykIndex$fRead2l[]Index $fShow1kIndex $fOrd1kIndex $fEq1kIndex $fShowIndex $fOrdIndex $fEqIndexSumInLInRnilSumdecomp injectSuminjprjindexelimSum$fWitnesspqSum$fWitnesspqSum0$fIxTraversable1k[]IndexSum$fTraversable1[]kSum$fIxFoldable1k[]IndexSum$fFoldable1[]kSum$fIxFunctor1k[]IndexSum$fFunctor1[]kSum $fRead1[]Sum $fShow1[]Sum $fOrd1[]Sum $fEq1[]Sum $fShowSum$fOrdSum$fEqSumFSumFInLFInRnilFSumfdecompfinjfprj injectFSumfindeximapFSum ifoldMapFSum itraverseFSum$fTraversableFSum$fFoldableFSum $fFunctorFSum:+:L'R':|:LR>|<>+<$fWitnesspq:+:$fWitnesspq:+:0$fBifunctor1Eitherlk:+:$fTraversable1Eitherk:+:$fFoldable1Eitherk:+:$fFunctor1Eitherk:+:$fKnownEither:+:Right$fKnownEither:+:Left$fRead1Either:+:$fShow1Either:+:$fOrd1Either:+:$fEq1Either:+:$fWitnesspq:|:$fBifunctor1mmm:|:$fTraversable1ll:|:$fFoldable1ll:|:$fFunctor1ll:|: $fRead1k:|: $fShow1k:|: $fOrd1k:|: $fEq1k:|: $fShow:+:$fOrd:+:$fEq:+: $fRead:|: $fShow:|:$fOrd:|:$fEq:|:OptionNothing_Just_option$fWitnesspqOption$fKnownMaybeOptionJust$fKnownMaybeOptionNothing$fTraversable1MaybekOption$fFoldable1MaybekOption$fFunctor1MaybekOption $fShowOption $fOrdOption $fEqOptionFProdØF:<<:>>onlyF>>:headFtailFinitFlastFreverseFappendFonHeadFonTailFuncurryFcurryFindexFimapF ifoldMapF itraverseF$fWitness(%,%)(%,%)FProd$fWitness(%%)(%%)FProd$fKnownkFProda$fKnownkFProda0$fTraversableFProd$fFoldableFProd$fFunctorFProd^^<==>==>BoolCN10N9N8N7N6N5N4N3N2N1N0>=><=<IxLen^MulW*AddW+PosPredIotaNatEqIsZeroNZSfromIntzeroCongzNotSiotaCongpredCongaddCongmulCongexpConglenCongixCong$fEqN$fOrdN$fShowN BoolEquality boolEqualityBooleanFalse_True_if'.?not'.||.&&.^^.==toBool$fKnownBoolBooleanFalse$fKnownBoolBooleanTrue$fTestEqualityBoolBoolean$fBoolEqualityBoolBoolean$fRead1BoolBoolean$fShow1BoolBoolean$fOrd1BoolBoolean$fEq1BoolBoolean $fShowBoolean $fOrdBoolean $fEqBooleanNatZ_S_pred' onNatPred_Z_S_s_ZneSaddZaddS.+.*.^elimNatnatVal$fBoolEqualityNNat$fTestEqualityNNat$fWitness(%%)KnownNat $fKnownNNatS $fKnownNNatZ $fRead1NNat $fShow1NNat $fOrd1NNat $fEq1NNat $fShowNat$fOrdNat$fEqNatLengthLZLS elimLengthlOddlEven$fWitness(%%)(%,%)Length$fKnown[]Length:$fKnown[]Length[]$fRead1[]Length$fShow1[]Length$fOrd1[]Length $fEq1[]Length $fShowLength $fOrdLength $fEqLengthFinFZFSelimFinfinsfinfinZweakenwithoutfinNat$fWitness(%%)~Fin $fBoundedFin $fEnumFin $fRead1NFin $fShow1NFin $fOrd1NFin $fEq1NFin $fShowFin$fOrdFin$fEqFinLessEqLTCliftIFinIFinIFZIFSifinZifinNatifinVal onIFinPred$fWitness(%%)~IFin $fLessEqSy $fLessEqZy $fRead2NNIFin $fShow2NNIFin $fOrd2NNIFin $fEq2NNIFin $fShow1NIFin $fOrd1NIFin $fEq1NIFin $fShowIFin $fOrdIFin$fEqIFinNatGTGTZGTSNatEQEQZEQSNatLTLTZLTS natCompare$fWitness(%%)(%,,,,%)NatGT$fWitness(%%)(%,,,,%)NatEQ$fWitness(%%)(%,,,,%)NatLT WitnessesTupleProd::<:>onlyhead'tail'init'last'reverse'append' lookupParpermutepermute'only_>::elimProdonHead'onTail'uncurry'curry'selecttoList$fWitness(%,%)(%,%)Prod$fWitness(%%)(%%)Prod$fKnown[]Prodas$fIxTraversable1k[]IndexProd$fTraversable1[]kProd$fIxFoldable1k[]IndexProd$fFoldable1[]kProd$fIxFunctor1k[]IndexProd$fFunctor1[]kProd$fTestEquality[]Prod$fBoolEquality[]Prod $fRead1[]Prod $fShow1[]Prod $fOrd1[]Prod $fEq1[]Prod $fShowProd $fOrdProd$fEqProd⊆SubsetsubNilsubReflsubTranssubProdsubSumsubIxsubExtsubExtByWithoutRemoveRZRSremLen elimRemoveremIxremSubixRemremProdremSum$fKnown[]Removebs$fWitness(%%)WithoutRemove$fWithoutk:acs$fWithoutk:abs$fTestEquality[]Remove$fRead3[]l[]Remove$fShow3[]l[]Remove$fOrd3[]l[]Remove$fEq3[]l[]Remove$fShow2[]kRemove$fOrd2[]kRemove$fEq2[]kRemove$fShow1[]Remove$fOrd1[]Remove $fEq1[]Remove $fShowRemove $fOrdRemove $fEqRemove WithoutAll withoutAll DifferenceØDdiffLenelimDifferencediffProddiffSum$fKnown[]Differencecs!$fWitness(%%)WithoutAllDifference$fWithoutAllaas:ds$fWithoutAllkas[]cs$fTestEquality[]DifferenceMatrixM getMatrixVecVecTØV:*:+elimVecTelimV.++vreponTailvDelimapifoldMap itraverseindex'vmapvapvfoldr vfoldMap'vfoldMapwithVecTwithVfindVfindVecTvgen_vgenmgen_mgenonMatrixdiagonal vtranspose transposem0m1m2m3m4ppVecppMatrix ppMatrix'mzipWithzipLinescompose$fNumM $fNumVecT$fWitness(%%)KnownVecT$fTraversableVecT$fFoldableVecT $fMonadVecT$fApplicativeVecT $fFunctorVecT$fTraversable1llVecT$fFoldable1llVecT$fFunctor1llVecT$fShowM$fOrdM$fEqM $fShowVecT $fOrdVecT$fEqVecT IntersectionUnionDeleteInsertLookupMemberEnvgetEnvmember'lookup'insert'delete' difference'.\\union' intersection'ixList$fIxFunctor1k[]IxListEnv$fFunctor1[]kEnvControl.CategoryCategory~~ Data.VoidvacuousVoidouterinnerapply gcastWithcastWithtranssym TestEquality testEquality==Data.Type.BoolIf&&||Not