Ni      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesSafe'>KLSafeCopyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*3579>IKLNUZ The empty .Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(357>IKLNUZ 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!"&'(*134579>IKLNUZ !$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 .- Convert a ! to a canonical reified .. Convert a !# to a canonical reified entailment.8Constraint chaining under Maybe.CIf the constraint c> holds, there is a canonical construction for a term of type ) c, viz. the constructor Wit.DA type equality a  b is a Witness that (a ~ b).EAn entailment p :- q is a Witness of q, given p.?  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKC  !"#$%&'()*+,-./0123456789:;<=>?@A?)*'($%&K+!"#,-. /JIH01234567GFEDCB89:;<=>? @A/  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK  #$,89>?Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*3579>IKLNUZ;A type-level pair is a Monoid over its pairwise components.LMNOPQRSTUVWXYZLMNOPQRSTUVWXYZTSURVQWPXOYNZMLLMNOPQRSTUVWXYZLMNTCopyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*3579>IKLNUZ`Map over a type-level Maybe.cTake a Maybe Constraint to a  Constraint.[\]^_`abcdefghijkl[\]^_`abcdefghijklcbadef`g_h^i]j\[kl[\]^_`abcdefghijkl]^_`Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*3579>IKLNUZtMap a list of (fs :: [k -> l]) over a single (a :: k), giving a list  (bs :: [l]).uMap an  (f :: k -> l) over a type-level list  (as :: [k]), giving a list  (bs :: [l]).vTakes 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.#mnopqrstuvwxyz{|}~  !mnopqrstuvwxyz{|}~!~}|{zyxwvutsrqponm#mnopqrstuvwxyz{|}~  stu~Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*3579>IKLNUZMap over a type-level Maybe.Take a Maybe Constraint to a  Constraint.     Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*3579>IKLNUZ  Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*3579>IKLNUZ/Convenient aliases for low-value Peano numbers.&%%$ Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(35>IKLNUZAn eliminator for a  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.---!  Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(13579>IKLNUZATake a natural transformation to a lifted natural transformation.F      !"#$%&'()*+,-./01234567F      !"#$%&'()*+,-./01234567F)*+,&'(-#$%. !"/   0  1234567       !"#$%&'()*+,-./01234567 !",-. Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*357>IKLNUZ;Eliminator for 8 f.A(We can take a natural transformation of (forall x. f x -> g x)! to a natural transformation of  (forall mx. 8 f mx -> 8 g mx). 89:;<=>?@A89:; 89:;A@?>=<89:;<=>?@ACopyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*-./1357>IKLNUZEBCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~#BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdEZ[\WXY~}TUV|{zyxw]QRS^vut_NOPsr`KLMqpoaHIJnmbEFGlkjcBCDihgfed3BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*357>IKLNUZCopyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*3579>IKLNUZ Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(357>IKLNUZ~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 :<< Build a singleton FProd.9snoc function. insert an element at the end of the FProd.2Get all but the last element of a non-empty FProd.*Get the last element of a non-empty FProd.!Reverse the elements of an FProd.Append two FProds.'Map over the head of a non-empty FProd.'Map over the tail of a non-empty FProd.EMap over all elements of an FProd with access to the element's index.FFold over all elements of an FProd with access to the element's index.JTraverse over all elements of an FProd with access to the element's index.GA non-empty FProd is a Witness if both its head and tail are Witnesses."An empty FProd is a no-op Witness.If all f in fs are  Traversables, then FProd fs is a  Traversable.If all f in fs are Foldables, then FProd fs is a Foldable.If all f in fs are Functors, then FProd fs is a Functor.Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(35>IKLNUZ )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!"&'(*3579>IKLNUZ   Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*357>IKLNUZ)There are no possible values of the type Sum f . Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*3579>IKLNUZ                          Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*3579>IKLNUZ# !"#$%&'()*+,-./01234567 !"#$#76543210/.-, !"+*)('#$&%! !"#$%&'()*+,-./01234567Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*3457>IKLNUZ 8A Prod of simple Haskell types.<{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 :< =Cons onto a Tuple.>Build a singleton Prod.?8snoc function. insert an element at the end of the list.B1Get all but the last element of a non-empty Prod.C)Get the last element of a non-empty Prod.JSingleton Tuple.KSnoc onto a Tuple.*89:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a89:;<=>?@ABCDEFGHIJKLMNOPQR*9:;a`_^]<>?@ABCDEFGHI8J=KLMNOPQR\[ZYXWVUTS(89:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a;<=?KCopyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*3579>IKLNUZk A proof that : is also a right identity for the addition of type-level bs.tA Nat n is a !- that there is a canonical construction for Nat n.uIf n is a canonical construction of Nat n, d n" is the canonical construction of  Nat (S n).vc$ is the canonical construction of a b Z.bcdefghijklmnopqrstuvwxyzbcdefghijklmnopqbcdzyxwvutsrefghijklmnopqbcdefghijklmnopqrstuvwxyzmnoCopyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*3457>IKLNUZ8Gives 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 b.A Fin n is a ! that n >= 1. That is,  n is well defined.{|}~ {|}~{|}~ {|}~Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*3457>IKLNUZAn IFin x y is a ! that x >= 1. That is,  x is well defined. None!"'(*3457>IKLNU   Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*13457>IKLNUZ9195Copyright (C) 2015 Kyle CarterBSD3"Kyle Carter <kylcarte@indiana.edu> experimental RankNTypesNone!"&'(*357>IKLNUZ    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHHIIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|klm}~klm|klm                                                                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M NOOPQQRSSTUUVWWXYYZ[[\]]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~>?       typec_DFoVtV68hHA0YKl2VWbDRoType.Family.ConstraintType.Family.MonoidType.Class.KnownType.Class.WitnessType.Family.TupleType.Family.EitherType.Family.ListType.Family.MaybeType.Family.BoolType.Family.NatData.Type.QuantifierType.Class.HigherData.Type.OptionData.Type.CombinatorData.Type.DisjunctionData.Type.IndexData.Type.Product.LiftedData.Type.Sum.LiftedData.Type.Length Data.Type.SumData.Type.BooleanData.Type.ConjunctionData.Type.Product Data.Type.Nat Data.Type.FinData.Type.Fin.IndexedData.Type.Nat.InequalityData.Type.Vector Data.Type.SymType.Family.Symbolghc-primGHC.Prim Constraint<>MemptyIffIffCFailØC $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∘kkfga $fConstkcd$fCategoryConstraint:-<*><&><$>Thd3Snd3Fst3SndFst#fstCongsndCongfst3Congsnd3Congthd3Cong pairMapCong FromRightFromLeft<|>IsRightIsLeftEitherCleftCong rightCong leftNotRighteitherFmapCongeitherPamfCong eitherApCong eitherAltCong fromLeftCong fromRightCongThds3Snds3Fsts3ZipSndsFstsListCLast'LastInit'InitTailHeadReverse>:Concat++NullOnly:<ØnullCong nilNotCons appendCong concatCongsnocCong reverseConginitConglastCong listMapCongFromJust IsNothingMaybeC nothingCongnothingNotJust maybeFmapCong maybePamfCong maybeApCong maybeAltCong fromJustCong^^<==>==>BoolCN10N9N8N7N6N5N4N3N2N1N0>=><=<IxLen^*+PredIotaNatEqIsZeroNZSfromIntzeroCongzNotSiotaCongpredCongaddCongmulCongexpConglenCongixCongEveryC instEveryCEvery3 instEvery3Every2 instEvery2Every instEverySomeCSome3Some2Somesome>>->->withSomeonSomemsome>>=-some2>>-->--> withSome2onSome2msome2>>=--some3>>--->---> withSome3onSome3msome3>>=---someC>>~msomeC>>=~ IxBifunctor1ibimap1 Bifunctor1bimap1IxTraversable1 itraverse1 Traversable1 traverse1 IxFoldable1 ifoldMap1 Foldable1foldMap1 IxFunctor1imap1Functor1map1Read3 readsPrec3Read2 readsPrec2Read1 readsPrec1Show3 showsPrec3show3Show2 showsPrec2show2Show1 showsPrec1show1Ord3compare3<###>###<=###>=###Ord2compare2<##>##<=##>=##Ord1compare1<#>#<=#>=#Eq3eq3neq3Eq2eq2neq2Eq1eq1neq1=#==##==###=shows1shows2shows3reads1 readMaybe1reads2 readMaybe2reads3 readMaybe3OptionNothing_Just_option$fWitnesspqOption$fKnownMaybeOptionJust$fKnownMaybeOptionNothing$fTraversable1kMaybeOption$fFoldable1kMaybeOption$fFunctor1kMaybeOptionJoingetJoinUncur3 getUncur3Cur3getCur3UncurgetUncurCurgetCurFlipgetFlipCgetCIgetI:.:CompgetCompmapCflipTestEquality1mapFlipmapCurmapUncurmapCur3 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$fTestEquality1(->)k:.:$fTestEqualityk:.:$fWitnesspq:.: $fShow1k:.: $fOrd1k:.: $fEq1k:.::+:L'R':|:LR>|<>+<$fWitnesspq:+:$fWitnesspq:+:0$fBifunctor1kkEither:+:$fTraversable1kEither:+:$fFoldable1kEither:+:$fFunctor1kEither:+:$fKnownEither:+:Right$fKnownEither:+:Left$fRead1Either:+:$fShow1Either:+:$fOrd1Either:+:$fEq1Either:+:$fWitnesspq:|:$fBifunctor1kkk:|:$fTraversable1kk:|:$fFoldable1kk:|:$fFunctor1kk:|: $fRead1k:|: $fShow1k:|: $fOrd1k:|: $fEq1k:|:Elem elemIndex∈IndexIZIS elimIndexixNilonIxPred$fKnownkIndexa$fKnownkIndexa0 $fElemk:a $fElemk:a0$fTestEqualitykIndex$fRead2[]kIndex $fShow1kIndex $fOrd1kIndex $fEq1kIndexFProdØF:<<:>>onlyF>>:headFtailFinitFlastFreverseFappendFonHeadFonTailFuncurryFcurryFindexFimapF ifoldMapF itraverseF$fWitness(,)(,)FProd$fWitness()()FProd$fKnownkFProda$fKnownkFProda0$fTraversableFProd$fFoldableFProd$fFunctorFProdFSumFInLFInRnilFSumfdecompfinjfprj injectFSumfindeximapFSum ifoldMapFSum itraverseFSum$fTraversableFSum$fFoldableFSum $fFunctorFSumLengthLZLS elimLengthlOddlEven$fKnown[]Length:$fKnown[]Length[]$fRead1[]Length$fShow1[]Length$fOrd1[]Length $fEq1[]LengthSumInLInRnilSumdecomp injectSuminjprjindexelimSum$fWitnesspqSum$fWitnesspqSum0$fIxTraversable1[]kIndexSum$fTraversable1k[]Sum$fIxFoldable1[]kIndexSum$fFoldable1k[]Sum$fIxFunctor1[]kIndexSum$fFunctor1k[]Sum $fRead1[]Sum $fShow1[]Sum $fOrd1[]Sum $fEq1[]Sum BoolEqualityBoolEqC.==BooleanFalse_True_not'.||.&&.^^$fKnownBoolBooleanFalse$fKnownBoolBooleanTrue$fBoolEqualityBoolBoolean$fRead1BoolBoolean$fShow1BoolBoolean$fOrd1BoolBoolean$fEq1BoolBoolean:*::&:fanFstfanSnd.&.fanFirst uncurryFancurryFanparFstparSnd uncurryParcurryPar_fst_snd$fWitness(,)(,):*:$fDecEquality(,):*:$fBifunctor1kk(,):*:$fTraversable1k(,):*:$fFoldable1k(,):*:$fFunctor1k(,):*:$fKnown(,):*:p $fShow1(,):*: $fOrd1(,):*: $fEq1(,):*:$fWitness(,)(,):&:$fBifunctor1kkk:&:$fTraversable1kk:&:$fFoldable1kk:&:$fFunctor1kk:&: $fKnownk:&:a $fShow1k:&: $fOrd1k:&: $fEq1k:&:TupleProd:>::<onlyhead'tail'init'last'reverse'append'lookup' lookupParpermutepermute'only_>::elimProdonHead'onTail'uncurry'curry'select$fWitness(,)(,)Prod$fWitness()()Prod$fKnown[]Prod:$fKnown[]Prod[]$fIxTraversable1[]kIndexProd$fTraversable1k[]Prod$fIxFoldable1[]kIndexProd$fFoldable1k[]Prod$fIxFunctor1[]kIndexProd$fFunctor1k[]Prod$fTestEquality[]Prod $fRead1[]Prod $fShow1[]Prod $fOrd1[]Prod $fEq1[]ProdNatZ_S_pred' onNatPred_Z_S_s_ZneSaddZaddS.+.*.^elimNatnatVal$fBoolEqualityNNat$fTestEqualityNNat$fWitness()KnownNat $fKnownNNatS $fKnownNNatZ $fRead1NNat $fShow1NNat $fOrd1NNat $fEq1NNatFinFZFSelimFinfinsfinfinZweakenwithoutfinNat$fWitness()~Fin $fRead1NFin $fShow1NFin $fOrd1NFin $fEq1NFinLessEqLTCliftIFinIFinIFZIFSifinZifinNatifinVal onIFinPred$fWitness()~IFin $fLessEqSy $fLessEqZy $fRead2NNIFin $fShow2NNIFin $fOrd2NNIFin $fEq2NNIFin $fShow1NIFin $fOrd1NIFin $fEq1NIFinNatGTGTZGTSNatEQEQZEQSNatLTLTZLTS natCompare$fWitness()(,,,,)NatGT$fWitness()(,,,,)NatEQ$fWitness()(,,,,)NatLTMatrixM getMatrixVVTØV:*:+elimVTelimV.++vreponTailvDelimapifoldMap itraversevmapvapvfoldr vfoldMap'vfoldMapwithVTwithVfindVfindVTvgen_vgenmgen_mgenonMatrixdiagonal vtranspose transposem0m1m2m3m4ppVecppMatrix ppMatrix'mzipWithzipLinescompose$fNumM$fNumVT$fWitness()KnownVT$fTraversableVT $fFoldableVT $fMonadVT$fApplicativeVT $fFunctorVTSymsymbol$fWitness()KnownSymbolSym$fKnownSymbolSymx$fBoolEqualitySymbolSym$fTestEqualitySymbolSym$fShow1SymbolSym$fOrd1SymbolSym$fEq1SymbolSym $fShowSymbase GHC.TypeLits KnownSymbolSymbol sameSymbol symbolValControl.CategoryCategoryData.Type.Equality:~: Data.VoidvacuousVoidouterinnerapply gcastWithcastWithtranssymRefl testEquality TestEquality==TFCo:R:Mempty(,)TFCo:R:<>(,,)(,,)(,,)TFCo:R:Mempty(,,)TFCo:R:<>(,)(,)(,)TFCo:R:<>EitherabTFCo:R:MemptyEither TFCo:R:<>[]abTFCo:R:Mempty[]TFCo:R:<>MaybeabTFCo:R:MemptyMaybeData.Type.Bool&&||Not TFCo:R:==Nxy