6e      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdNone/A class without instances for explicit failure A predicate for type equality %There are different implementations. See imports in Main*.hs  Less than $ Establish type equality statically 6 Establish remaining value-level equality dynamically K  !"#$%&'()*+,efghijklmnopqrstuvwxyz{|}~-  !"#$%&'()*+,- !" # $%&'()*+,C    !"#$%&'()*+,efghijklmnopqrstuvwxyz{|}~None - Analogus to Data.List.partition snd 7Same as  hMapOut Id <Like  W Identity cThe class HAppend r!The normal append for comparison sNote: x :: HCons a b means: forall a b. x :: HCons a b hEnd x means: exists a b. x :: HCons a b List termination xAlternative implementation of d. Demonstrates U ySame as T" only a different implementation. ~(Annotate list with a type-level Boolean Normal function application )The instance following the normal append -./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~R-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Rnolmkpqijghefrcdab_`]^st[\YZWXUVSTQRuvwxOPMNyKLIJGHFECDAB@z?>={;<9:78563412/0|}~-.z-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~NoneZip and unzip NoneThis special type equality/comparison is entirely pure! from 1 to x - 1 (Splitting an array according to indices Signature is inferred: O hSplitByHNats :: (HSplitByHNats' ns l' l'1 l'', HMap (HAddTag HTrue) l l') => % ns -> l -> (l'1, l'') 0'None( NoneMap types to naturals  Helper class Map a type to a natural CDefine type-indexed delete in terms of the natural-based primitive @Define type-indexed update in terms of the natural-based update Projection based on proxies Splitting based on proxies  NoneType-indexed type sequences &The newtype for type-indexed products Type-indexed extension signature is inferred O hExtend' :: (HTypeIndexed t, HOccursNot e t) => e -> TIP t -> TIP (HCons e t) "Shielding type-indexed operations E The absence of signatures is deliberate! They all must be inferred. <This example from the TIR paper challenges singleton lists. K Thanks to the HW 2004 reviewer who pointed out the value of this example. H We note that the explicit type below is richer than the inferred type. H This richer type is needed for making this operation more polymorphic.  That is, a); would not work without the explicit type, while it would: + a) ((+) (1::Int)) $ snd $ tuple oneTrue + b) ((+) (1::Int)) $ fst $ tuple oneTrue A specific tuple         None?A type-indexed type sequence that is a sequence of proxy types (A datatype for type-indexed co-products Public constructor Public destructor  TICs are opaque    NoneHelper class 2 for  Helper class for   Invariant: ! r === rin `disjoint-union` rout  labels rin === ls . where (rin,rout) = hProjectByLabels ls r #This is a baseline implementation. G We use a helper class, HasField, to abstract from the implementation. Because , is so frequent and important, we implement G it separately, more efficiently. The algorithm is familiar assq, only 2 the comparison operation is done at compile-time ,Construct the list of values of the record. 6Construct the (phantom) list of labels of the record. &This is a purely type-level function. EPropery of a proper label set for a record: no duplication of labels #Field of label l with value type v Label accessor Build a record Build an empty record hProjectByLabels ls r returns r with only the labels in ls remaining See  Rename the label of record We could also say:  < hTPupdateAtLabel l v r = hUpdateAtLabel l v r `asTypeOf` r +Then we were taking a dependency on Haskell's type equivalence. GThis would also constrain the actual implementation of hUpdateAtLabel. A variation on : type-preserving update. JRearranges a record by labels. Returns the record r, rearranged such that E the labels are in the order given by ls. (recordLabels r) must be a  permutation of ls. For improved error messages For improved error messages <Field f2 is already in r1, so it will be in the union of r1  with the rest of r2. =To inject (HCons f2 r2) in that union, we should replace the  field f2 Subtyping for records a !"#$%&'()*+,-./01234567888N !"#$%&'()*+,-./012345678 None.Turn proxy sequence into sequence of Nothings 1Variant types on the basis of label-maybe pairs.  Public constructor  Public destructor 9Variants are opaque    9:;         9:;None<=><=> None ?@ABCD   ?@ABCDNoneEE None  FGH   FGH None# !"#IJKLMNOPQRSTUVWXYZ !"# !"# !"#IJKLMNOPQRSTUVWXYZNone$%&'[\]^$%&''&%$$%&'[\]^None(Labels are type-level naturals *Public constructors for labels +Construct the first label ,Construct the next label _ Show label `Equality on labels ()*+,_`()*+,()*+,()*+,_`None-Labels are type-level naturals .Construct the first label /Construct the next label a Show label b.Equality on labels (descriptions are ignored) -./cab-./-./-./cabNone0Labels are type-level naturals 1Construct the first label 2Construct the next label d Show label e.Equality on labels (descriptions are ignored) 012fde012012012fdeNoneg Show label hEquality on labels ghghNonei Show label jEquality on labels ijijNone3Our main function 4Make a single label klmnopq34rstuvw3434klmnopq34rstuvwNone 56789xyz{|}~5678978659 56789xyz{|}~None<&Record equivalence modulo field order JDecide if two records r1 and r2 are identical or differ only in the order  of their fields. EIf the two record types are indeed equivalent, return the witness of I their equivalence, (HJust (r1->r2,r2->r1)). If they are not equivalent,  return HNothing BThe function equivR does not examine the values of its arguments:  it needs only their types. KThe algorithm is simple: two records are equivalent if one can be narrowed G to the other, and vice versa. The narrowing coercions are the desired  witnesses. JThe obvious optimization is to check first if two records are of the same 7 type. That requires TypeEq however. Perhaps we shouldn't use it here. H Use of the record narrowing tacitly assumes that the label of a record F field uniquely determines the type of the field value. Therefore, we D should not use equivR on two records with inconsistent labeling... >/Extension of lubNarrow to a heterogeneous list B)List constructors that also LUB together C.Narrow two records to their least-upper bound K+Narrow a record to a different record type  First is the monadic version, which returns the `failure indictator' D (HNothing) if the narrowing fails because the source does not have  all the fields for the target. OA variation on update. 0Replace a proxy by a value of the proxied type.  The signature is inferred P Test for values; refuse proxies 7:;<=>?@ABCDEFGHIJKLMNOPQRSTUV:;<=>?@ABCDEFGHIJKLMNOPQRSTUVOPNMKLIJGHEFCDBQ@A>?<=:;RSTUV.:;<=>?@ABCDEFGHIJKLMNOPQRSTUVNone Z (.*.) : Add a field to a record. Analagous to (++) for  lists.  record .*. field1  .*. field2 [9Create a value with the given label. Analagous to a data  constructor such as , , or . Higher fixity A than record-modification operations like (.*.), (.-.), etc. to % support expression like the below w/o parentheses:  label1 .=. value1 .*.  label2 .=. value2 .*.  emptyRecord \ALookup a value in a record, by its label. Analagous to (!!), the 6 list indexing operation. Highest fixity, like (!!). + record1 .*. label1 .=. record2 .!. label1 + .*. label2 .=. record2 .!. label2 ]*Remove a field from a record. At the same > level as other record modification options (.*.). Analagous  to (\ ) in lists.   record1 .-. label1   label1 .=. value1 .*.  label2 .=. value2 .-.  label2 .*.  emptyRecord   label1 .=. value1 .-.  label1 .*.  label2 .=. value2 .*.  emptyRecord + record1 .*. label1 .=. record2 .!. label1 + .*. label2 .=. record2 .!. label2  .-. label1 ^(Update a field with a particular value. F Same fixity as (.*.) so that extensions and updates can be chained. D There is no real list analogue, since there is no Prelude defined  update.  label1 .=. value1 .@. record1 _=This is a variation on updating (according to GhcRecord.hs),  so use the same fixity as (.@.). `=Another variation on update, so give it the same fixity as (.@.). a@Similar to list append, so give this slightly lower fixity than  (.*.), so we can write: , field1 .=. value .*. record1 .<++. record2 b4Type-indexed rows append. Very similar to (.*.), so  keep the same fixity. WXYZ[\]^_`ab WXYZ[\]^_`ab YXZ[\]^_`aWb WXYZ[\]^_`abNone   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   Nonecd      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcddccd  !"#$%&'()**++,-./0123456789:;<=>?@ABCDEFGHIJKKLLMNOPQRSTUVWXYZ[\]^_`abccddeeffghijklmmnopqrstuvwxyz{|}~                                                       # $      ! " # $ % & & ' ( ) * +,-%A../01.01.012/3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                        ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 789: ; < = > ? @A B C D E F G H I J K L M N O P Q R S T U VWXY?Z[Z[\Z]\^_`abcdefghijklmnopqrstuvwxyz{|}~      HList-0.2.3Data.HList.FakePreludeData.HList.HListPreludeData.HList.HZipData.HList.HArrayData.HList.HOccursData.HList.HTypeIndexedData.HList.TIPData.HList.TICData.HList.RecordData.HList.VariantData.HList.TypeEqGeneric1Data.HList.TypeCastGeneric2Data.HList.RecordPData.HList.TypeEqGeneric2Data.HList.Label1Data.HList.Label2Data.HList.Label3Data.HList.MakeLabelsData.HList.GhcExperimentsData.HList.GhcRecordData.HList.GhcSyntax Data.HList Data.List intersectData.HList.TypeEqBoolGenericData.HList.TypeCastGeneric1Data.HList.Label4Data.HList.Label5Data.HList.CommonMainFailSubType TypeEqFalse TypeEqTrueProxyTypeCasttypeCastTypeEqHLt HStagedEq hStagedEqHEqHJustHNothing HNat2Integral hNat2IntegralHNatHSuccHZeroHCondhCondHOrhOrHAndhAndHBoolHFalseHTruehTruehFalsehZerohSucchPredhEqhLttypeEqproxyEqproxytoProxyunProxy typeEqTrue typeEqFalsesubTypeHSplithSplitHRmTagHAddTag FromHJust fromHJustToHJusttoHJust HList2List hList2ListHTIntersectBoolhTIntersectBool HTIntersect hTIntersectHTMember HMemberM'HMemberMHMemberHFind'hFind'HFindhFindHSetHNats HStagedEq' hStagedEq'HSeqHShowHMap' ApplyHConsHMapOuthMapOutHMaphMapHFoldrhFoldrIdApplyapplyHBuild'hBuild' NaiveHReverse naiveHReverse HReverse' hReverse'HReversehReverseHAppendhAppendHExtendhExtendHTailhTailHHeadhHeadHListHConsHNilhNilhConsappendhEndhBuildhMapMhMapM_append'hAppend'hMap'hMemberhTMemberhAddTaghRmTaghFlagHZiphZiphUnzip HSingleton HMinLength HMaxLengthHLength HOrdMember hOrdMemberHDiffhDiffHBetweenhBetweenHProjectAwayByHNatshProjectAwayByHNatsHProjectByHNatshProjectByHNatsHSplitByHNats'hSplitByHNats' HUpdateAtHNat hUpdateAtHNat HDeleteAtHNat hDeleteAtHNat HLookupByHNat hLookupByHNat hSplitByHNatshLengthhSingleHProjecthProject HOccursNot TypeFound HOccursOpt hOccursOpt HOccursBool hOccursBoolHOccurs'hOccurs' TypeNotFoundHOccurshOccurs HOccursFst hOccursFst HOccursMany1 hOccursMany1 HOccursMany hOccursMany HTypes2HNats hTypes2HNatsHType2HNatCase HType2HNatHDeleteManyCasehDeleteManyCase HDeleteMany hDeleteMany hType2HNathDeleteAtProxy hUpdateAtTypehProjectByProxieshSplitByProxies HTypeIndexedTIPmkTIPunTIPemptyTIPhExtend'onTIP tipyDelete tipyUpdate tipyProject tipySplittupleoneTrue HTypeProxiedTICmkTICunTIC FieldNotFound ExtraField HRearrange' hRearrange2' HRearrange hRearrange2 UnionSymRec'unionSR' UnionSymRecunionSRHLeftUnionBoolhLeftUnionBool HLeftUnion hLeftUnionH2ProjectByLabels'h2projectByLabels'H2ProjectByLabelsh2projectByLabels HasField'hLookupByLabel'HasFieldhLookupByLabel ShowLabel showLabelShowComponentsshowComponents RecordValues recordValues' RecordLabelsDuplicatedLabel HLabelSet' HLabelSet HRLabelSet' HRLabelSetRecordLVPair valueLVPair labelLVPair newLVPairmkRecord emptyRecord recordLabels' recordLabels recordValueshDeleteAtLabelhUpdateAtLabelhProjectByLabelshProjectByLabels2 hRenameLabelhTPupdateAtLabel hRearrangeHMaybiedhMaybiedVariant mkVariant unVariant TupleType TypeCast'' typeCast'' TypeCast' typeCast'HProjectByLabelP'h2ProjectByLabelP'HProjectByLabelPh2ProjectByLabelP HasFieldP'hLookupByLabelP' RecordR2P record_r2p record_p2r HSameLengthRecordP mkRecordP emptyRecordPlabels_of_recordphDeleteAtLabelPhUpdateAtLabelPTypeEq''TypeEq'Labellabel firstLabel nextLabel makeLabelsIsTC2IsTC1funType RecordEquiv'equivR' RecordEquivequivRHLubhLubConsLubconsLubNilLub LubNarrow lubNarrowNarrownarrow NarrowM'' narrowM''NarrowM'narrowM'NarrowMnarrowM HasNoProxies ProxyFound hUnproxyLabel hasNoProxiesnilLub hNilTcName hConsTcName recordTcName hFieldTcName proxyTcName:+::=::*:.*..=..!..-..@..^..<..<++..+.#concrete $fShowProxy$fHLtHSuccHSuccb$fHLtHSuccHZeroHFalse$fHLtHZeroHSuccHTrue$fHLtHZeroHZeroHFalse$fHEqHSuccHSuccb$fHEqHSuccHZeroHFalse$fHEqHZeroHSuccHFalse$fHEqHZeroHZeroHTrue$fHNat2IntegralHSucc$fHNat2IntegralHZero $fShowHSucc $fShowHSucc0 $fShowHZero $fHNatHSucc $fHNatHZero$fHCondHTruexyx$fHCondHFalsexyy$fHOrHTrueHTrueHTrue$fHOrHFalseHTrueHTrue$fHOrHTrueHFalseHTrue$fHOrHFalseHFalseHFalse$fHAndHTrueHTrueHTrue$fHAndHFalseHTrueHFalse$fHAndHTrueHFalseHFalse$fHAndHFalseHFalseHFalse $fShowHFalse $fShowHTrue $fHBoolHFalse $fHBoolHTrue $fApply(->)xy$fHAppendHNilll$fHSplitHConsl'HCons$fHSplitHConsHConsl''$fHSplitHNilHNilHNil$fApplyHRmTag(,)e$fApplyHAddTage(,)$fFromHJustHConsHCons$fFromHJustHConsl'$fFromHJustHNilHNil$fToHJustHConsHCons$fToHJustHNilHNil$fHList2ListHConse$fHList2ListHNile$fHTIntersectBoolHFalsehtl1l2$fHTIntersectBoolHTruehtl1HCons$fHTIntersectHConsl1l2$fHTIntersectHNillHNil$fHTMembereHConsb''$fHTMembereHNilHFalse$fHMemberM'HJusteHConsHJust$fHMemberM'HNothingelHNothing$fHMemberM'HFalseeHConsres$fHMemberM'HTrueeHConsHJust$fHMemberMeHConsres$fHMemberMeHNilHNothing$fHMembereHConsb''$fHMembereHNilHFalse$fHFind'HFalseelHSucc$fHFind'HTrueelHZero$fHFindeHConsn $fHSetHCons $fHSetHNil $fHNatsHCons $fHNatsHNil$fHStagedEq'HTrueee$fHStagedEq'HFalseee'$fHStagedEqHConsHCons$fHStagedEqHConsHNil$fHStagedEqHNilHCons$fHStagedEqHNilHNil$fHEqHConsHConsb''$fHEqHConsHNilHFalse$fHEqHNilHConsHFalse$fHEqHNilHNilHTrue$fApplyHSeq(,)m$fApplyHShowxIO$fApplyHMap'(,)HCons$fApplyApplyHCons(,)HCons$fHMapOutfHConse'$fHMapOutfHNile$fHMapfHConsHCons$fHMapfHNilHNil$fHFoldrfvHConsr'$fHFoldrfvHNilv $fApplyIdxx$fHBuild'la(->)$fHBuild'laHCons$fNaiveHReverseHConsl''$fNaiveHReverseHNilHNil$fHReverse'l1HConsl3$fHReverse'l1HNill1$fHReversel2l3$fHAppendHConsl'HCons$fHExtendeHConsHCons$fHExtendeHNilHCons $fHTailHConsl $fHHeadHConse $fHListHCons $fHListHNil$fHZipHConsHConsHCons$fHZipHNilHNilHNil $fHSingletonl$fHMinLengthls$fHMaxLengthls$fHLengthHConsHSucc$fHLengthHNilHZero$fHOrdMembereHConsb$fHOrdMembereHNilHFalse$fHDiffHConsyz'$fHDiffHNilxHNil$fHBetweenHSuccz$fHBetweenHSuccHCons$fHProjectAwayByHNatsnsll' $fHProjectByHNatsHConsHConsHCons$fHProjectByHNatsHNilHConsHNil$fHProjectByHNatsHNilHNilHNil$fHSplitByHNats'HConslHConsl''$fHSplitByHNats'HNillHNill' $fHUpdateAtHNatHSucce'HConsHCons $fHUpdateAtHNatHZeroe'HConsHCons$fHDeleteAtHNatHSuccHConsHCons$fHDeleteAtHNatHZeroHConsl$fHLookupByHNatHSuccHConse'$fHLookupByHNatHZeroHConse$fHProjectlHCons$fHProjectlHNil$fHOccursNoteHCons$fHOccursNoteHCons0$fHOccursNoteHNil$fHOccursOpteHCons$fHOccursOpteHCons0$fHOccursOpteHNil$fHOccursBoolHFalseeHCons$fHOccursBoolHTrueeHCons$fHOccurs'eHCons$fHOccurseHCons$fHOccurseHCons0$fHOccurseHNil$fHOccursFsteHCons$fHOccursFsteHCons0$fHOccursMany1eHCons$fHOccursMany1eHCons0$fHOccursManyeHCons$fHOccursManyeHCons0$fHOccursManyeHNil$fHTypes2HNatsHConslHCons$fHTypes2HNatsHNillHNil$fHType2HNatCaseHFalseelHSucc$fHType2HNatCaseHTrueelHZero$fHType2HNateHConsn $fHDeleteManyCaseHFalseee'lHCons$fHDeleteManyCaseHTrueeell'$fHDeleteManyeHConsl'$fHDeleteManyeHNilHNil$fSubTypeTIPTIP$fSubTypeTIPTIP0$fHOccursOpteTIP$fHOccursFsteTIP$fHOccursMany1eTIP$fHOccursManyeTIP$fHAppendTIPTIPTIP$fHExtendeTIPTIP$fHOccursNoteTIP $fHOccurseTIP$fHOccurseTIP0$fHTypeIndexedHCons$fHTypeIndexedHNil $fShowTIC$fHTypeProxiedHCons$fHTypeProxiedHNil$fHRearrangeHNilHConsExtraField%$fHRearrange'llsHNilroutFieldNotFound$$fUnionSymRec'HTruer1LVPairr2'Record$fSubTypeRecordRecord$fHRearrange'llsHConsroutHCons$fHRearrangeHConsrr'$fHRearrangeHNilHNilHNil!$fUnionSymRec'HFalser1f2r2'Record$fUnionSymRecRecordRecordru$fUnionSymRecr1Recordr1$fHLeftUnionBoolHFalserfHCons$fHLeftUnionBoolHTruerfr$fHLeftUnionRecordRecordr''$fHLeftUnionrRecordr+$fH2ProjectByLabels'HNothinglsHConsrinHCons)$fH2ProjectByLabels'HJustlsHConsHConsrout$$fH2ProjectByLabelsHConsHConsrinrout$$fH2ProjectByLabelsHConsHNilHNilHNil$fH2ProjectByLabelsHNilrHNilr$fHasField'HFalselHConsv$fHasField'HTruelHConsv$fHasFieldlHConsv$fHasFieldlRecordv$fHAppendRecordRecordRecord$fHExtendLVPairRecordRecord$fShowComponentsHCons$fShowComponentsHNil $fShowRecord$fRecordValuesHConsHCons$fRecordValuesHNilHNil$fRecordLabelsHConsHCons$fRecordLabelsHNilHNil$fHLabelSet'xlsHTrue$fHLabelSet'xlsHFalse$fHLabelSetHCons$fHLabelSetHNil$fHRLabelSet'l1v1l2v2HTruer$fHRLabelSet'l1v1l2v2HFalser$fHRLabelSetHCons$fHRLabelSetHCons0$fHRLabelSetHNil $fShowVariant$fHMaybiedHConsHCons$fHMaybiedHNilHNil$fTypeEqFalsexy$fTypeEqFalsexx$fTypeEqTruexx $fTupleTypexb$fTupleType(,,)HTrue$fTupleType(,)HTrue$fTupleType()HTrue $fTypeEqxyb$fTypeEqxxHTrue $fTypeCastxx$fTypeCast''()aa$fTypeCast'tab $fTypeCastab$fSubTypeRecordPRecordP-$fH2ProjectByLabels'HFalselsRecordPrinRecordP-$fH2ProjectByLabels'HTruelsRecordPRecordProut#$fH2ProjectByLabelslsRecordPrinrout-$fH2ProjectByLabelsHConsRecordPRecordPRecordP/$fHProjectByLabelP'HFalselHConsHConsHConsvHCons($fHProjectByLabelP'HTruelHConsHConslsvvs!$fHProjectByLabelPlHConsvslsovvso$fHasFieldP'HFalselRecordPv$fHasFieldP'HTruelRecordPv$fHasFieldlRecordPv$fHAppendRecordPRecordPRecordP$fHExtendLVPairRecordPRecordP $fShowRecordP$fRecordR2PHConsHConsHCons$fRecordR2PHNilHNilHNil$fHSameLengthHConsHCons$fHSameLengthHNilHNil$fTypeEq''()xyHFalse $fTypeEq'qxyb$fTypeEq'()xxb$fShowLabelLabel$fHEqLabelLabelb $fShowLabel$fHEqLabelLabelb''$fShowLabelProxy$fHEqProxyProxyb $fShowLabelx$fHEqxyb ReplaceSyntax replace_name capitalize uncapitalize make_tname make_dname dcl_template show_codet4$fReplaceSyntaxType$fReplaceSyntaxExp$fReplaceSyntaxDec$fReplaceSyntax[] $fIsTC2fxb $fIsTC2ffb $fIsTC1fxb $fIsTC1ffb$fHDeleteManyeHConsl''$fTypeableProxy$fTypeableLVPair$fTypeableRecord$fTypeableHCons$fTypeableHNil$fRecordEquiv'(->)(->)HNothing$fRecordEquiv'(->)pj2HNothing$fRecordEquiv'(->)(->)HJust$fRecordEquivr1r2res $fHLubHConse $fHLubHConse0$fConsLube0[][]$fConsLubeNilLub[]$fLubNarrowRecordRecordRecord$fNarrowrHCons $fNarrowaHNil$fNarrowM''fHJustHJust$fNarrowM''fHNothingHNothing$fNarrowM'HConsroutbres$fNarrowM'HNilroutbHNothing$fNarrowMaHConsres$fNarrowMaHNilHJust$fHasNoProxiesHCons$fHasNoProxiesHCons0$fHasNoProxiesHCons1$fHasNoProxiesHNilbase Data.MaybeJust Data.EitherLeftRightGHC.Basefail>>=>>fmapreturnControl.Monad.Fixmfix Control.MonadguardliftMMonadFunctorData.Typeable.InternalTypeable Typeable1 Typeable2 Typeable3 Typeable4 Typeable5 Typeable6 Typeable7MonadFix MonadPlusghc-primGHC.Prim RealWorldGHC.STST Data.STRef modifySTRef' modifySTRefControl.Monad.ST unsafeSTToIO unsafeIOToSTunsafeInterleaveST Data.Functionfix Data.IORefatomicWriteIORefatomicModifyIORef'atomicModifyIORef modifyIORef' modifyIORef mkWeakIORef Data.Typeablegcast2gcast1gcastmkTyCon typeRepKey TypeRepKey showsTypeReptypeOf6DefaulttypeOf5DefaulttypeOf4DefaulttypeOf3DefaulttypeOf2DefaulttypeOf1Default typeOfDefault tyConString typeRepArgs typeRepTyConmkTyCon3mkAppTy funResultTy splitTyConAppmkFunTy tyConName tyConModule tyConPackagetypeOf1typeOf2typeOf3typeOf4typeOf5typeOf6typeOf7 GHC.IORef writeIORef readIORefnewIORefIORef GHC.STRef writeSTRef readSTRefnewSTRefSTRefGHC.IOstToIOcastmfilterapliftM5liftM4liftM3liftM2unlesswhen replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMjoinvoidforever<=<>=>msumforM_forMfilterMmapM_mapM sequence_sequence=<<mplusmzerorunSTfixST mkTyConAppTypeRepTyContypeOf