!h7&      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None$&',./145678=>?@ACHPSUVXk/  #$ %&' ()*+  ,-./01S23! "4xytswuonvqpr5XVWU67T89:;HK<=>?@AIJBNOPCDEFLMGQRYZ[\]^_`abcdefghijklmz{|}~ #$ %&' ()*+  ,-./01S3! "4xytswuonvqpr5XVWU89;HK<=>?@AIJBNOPCDEFLMQRYZ[\]^_`abcdefghijklmz{|}~:76G2TNone$&',./145678=>?@ACHMPSUVXkBdinoA wrapper for Q with a 1 instance that omits quotesUseful in situations where S' is (ab)used to provide conversion to Q# rather than for displaying values.dino+Marks a part of a value that hasn't changeddinoEmphasize when dino)Place a document indented under a header: header doc doc ...dino&Render a list of documents as follows: [ a , b , ... ]where '[', ',' and ']', are provided as the first three parameters.dinoRender a record as follows: 4{ field1 = value1 , field2 = value2 , ... }If k is a Q.-like type, it will be shown with quotes. Use  to prevent this.dinoReturns  iff. any argument is .dinoHeaderdino"Document to place under the header None $&',-./145678=>?@ACHPSUVXkVPdino,Representation of abstract syntax and values is parameterized by the representation of numbers. This makes it possible to affect the exactness of comparisons. For example a newtype with approximate equality can be used instead of e.g. =.dinoNumeric literaldino Text literaldino&Application of constructor or variabledino v a body binds v to a in bodydino(Description of a constructor or variabledinoGlobal constructor or variabledinoLocal variabledinoUser annotation#dinoVRepresent a list as a record, if the elements contain a value that can be used as key$dinoConversion from  to BBuilt-in consturctors (tuples and lists) are shown prepended with #.Record fields are shown as  fieldName:.Local variables are shown as *varName (both at binding and use site).,Annotations are shown as "ANN: annotation ".%dinoShow an  using Unicode art&dinoDraw an " on the terminal using Unicode art'dino Convert an $ to an HTML file with foldable nodes(dinoIf k is a Q.-like type, it will be shown with quotes. Use  to prevent this.,dino Creates a  constructor/variable#dinoExtract the key%      !"#$%&'% !"     #$%&'None$&',./145678=>?@ACHPSUVXkj^dino3Representation of the difference between two values_dino+Calculate the difference between two valuesThe result is I iff. the two values are equal.The following property holds: %If Just d = diff a b Then Just b = ` d a `dino Apply an d to a ValueUThis function is mostly intended for testing. It succeeds iff. the edit makes sense.adinoEWrapper for values that should be regarded as monolithic when diffingddinoEdit operation on a jdinoEdit operations on listsldino$Edit operations at the end of a listodino&Edit operations on an optional elementwdino"Drop elements at the end of a listydino]Pretty print for edits on tuple-like collections (where elements are identified by position)zdino Pretty print f for "named" constructors{dino Print an d( value to the terminal using ANSI colors|dinoPrint a diff as a test resultI is shown as a green "OK".J d? is shown as a red "Fail", followed by a rendering of the diff.dino]Matches element-wise from the start of the lists, and detects additions/removals at the end.dinoIf k is a Q.-like type, it will be shown with quotes. Use  to prevent this._dinoOriginaldinoNew ]`_^abcdihgfejklnmorqpstuvwxyz{| wstuvorqplnmjkdihgfeabc]`_^xyz{|None$&',./145678=>?@ACHMPSUVXkqdinoDynamic type based on dinoBuilt-in Dino typesEWhether or not a type is built-in is mostly an implementation detail.dino/This instance is complete in the sense that if t ~ u, then  (trep ::  t) (urep ::  u) returns J . For example, BoolType and EnumType ::  ; are considered equal.    None $&',-./145678=>?@ACHMPSUVXk֫,dino expressions with a ) instance" is handy to avoid nested uses of 3. As an example, here is a safe division function: safeDiv :: _ => e a -> e a -> Optional e (e a) safeDiv a b = suppose $ if (b /= lit 0) then just (fdiv a b) else nothingKAnd here is a calculation that defaults to 0 if any of the divisions fails: foo :: _ => Exp e Double -> Exp e Double -> Exp e Double foo a b = fromOptional 0 $ do x <- safeDiv a b y <- safeDiv b x safeDiv x ydinoAUseful wrapper to get a concrete type for tagless DSL expressions<The problem solved by this type can be explained as follows:BSuppose you write a numeric expression with the most general type: !myExp1 :: Num e => e myExp1 = 1+29And suppose you define an evaluation function as follows: Leval1 :: (forall e . (ConstExp e, NumExp e) => e a) -> a eval1 = runIdentity#The problem is that we cannot pass myExp1 to eval1: !test1 :: Int test1 = eval1 myExp1This leads to: $ " Could not deduce (Num (e Int)) ...And we don't want to change eval1 to Ceval1 :: (forall e . (ConstExp e, NumExp e, Num (e a)) => e a) -> asince this requires the expression to return a number (and not e.g. a Boolean), and it also doesn't help to satisfy any internal numeric expressions that may use a different type than a. Instead, the solution is to use  as follows: myExp2 :: (ConstExp e, NumExp e, Num a) => Exp e a myExp2 = 1+2 eval2 :: (forall e . (ConstExp e, NumExp e) => Exp e a) -> a eval2 = runIdentity . unExp test2 :: Int test2 = eval2 myExp2*The trick is that there exists an instance 7instance (Num a, ConstExp e, NumExp e) => Num (Exp e a)So it is enough for eval2 to supply constraints on e;, and it will automatically imply the availability of the + instance.dinoAssert that a condition is trueInterpretations can choose whether to ignore the assertion or to check its validity. The default implementation ignores the assertion.7The following must hold for any monadic interpretation:  lab c a  ( lab c ( ())   a) dinoOAssert that an expression is semantically equivalent to a reference expressionInterpretations can choose whether to ignore the assertion or to check its validity. The default implementation ignores the assertion.7The following must hold for any monadic interpretation:  lab ref act  ( do a <- act  lab ref ( a) return a ) dinoAnnotate an expressiondinoShare a value in a calculationThe default implementation of  implements call-by-value.dino Left folddinoHelper class to ' containing only first-order constructsDThe reason for having this class is that there are types for which  can be derived but  cannot.dino#Expressions supporting conditionals<The default implementations are for monadic interpretations.dinoDeconstruct an optional valuedinoHelper class to ' containing only first-order constructsDThe reason for having this class is that there are types for which  can be derived but  cannot.dino+Construct an optional value that is presentdinoCase expressiondino$Case expression without fall-through2Evaluation may fail if the cases are not complete.dinoMarker for the default case in dinoRepresentation of a case in dino Comparisons$The default implementations are for 3 interpretations.dinoLogic expressions$The default implementations are for 3 interpretations.dinoFractional expressions"The default implementation is for 3 interpretations.dinoDivisiondinoNumeric expressions$The default implementations are for 3 interpretations.dino&Convert an integer to any numeric typedino x/ returns the greatest integer not greater than xdino x returns the integer nearest x between zero and xdino)Round to the specified number of decimalsdinoConstant expressions"The default implementation is for 3 interpretations.dino(Make a Dino literal from a Haskell valuedinoConstant text expressionWith OverloadedStrings2 enabled, text literals can be written simply as "...".dino Convert an @ to any numeric typedino1Division that returns 0 when the denominator is 0dino'Check equality against a constant valuedinoConstruct a case in ,  , etc.Example: beaufortScale :: _ =>  e a ->  e  beaufortScale v =   v [ ( 0.5)  "calm" , ( 13.8)  "breeze" , ( 24.5)  "gale" ] (   "storm" ) dino+Construct an optional value that is missing dino4Case expression using Boolean functions for matching dino2Case expression matching a value against constantsExample: operate c a =   c [  a + 1 ,   a - 1 ] (  a)  dino A Version of  9 for enumerations where the cases cover the whole domain>An error is thrown if the cases do not cover the whole domain. dinoConditional expressionEnable RebindableSyntax to use the standard syntax if a then b else c for calling this function.dinoShare a value in a calculationLike 2 but with the variable base name fixed to "share".dino&Make a function with a shared argument  =   Like 2 but with the variable base name fixed to "share".dinoExtract a field from a recordUse as follows (with OverloadedLabels): field #name $ field #driver cardinoExtract a field from a recordUse as follows (with OverloadedLabels): #name <. #driver <. cardinoLift an optional expression to dino Convert from  value to an optional expression!dino Extract an  valuedinoAssertion labeldinoCondition that should be truedino%Expression to attach the assertion todinoAssertion labeldinoReference expressiondinoActual expressiondinoVariable base namedinoValue to sharedinoBodydinoReducer functiondino Initial valuedino(List to reduce (traversed left-to-right)dinoLower bound (inclusive)dinoUpper bound (inclusive)dino Result when dino Result when dinoValue to deconstructdinoGuarded expressionsdinoFall-through casedinoGuarded expressions dino ScrutineedinoCasesdinoFall-through case dino ScrutineedinoCasesdinoFall-through case dino ScrutineedinoCases dino Conditiondino True branchdino False branchdinoValue to sharedinoBodydinoBodydinoValue to sharedinoResult if missingdinoResult if presentdinoValue to examine!dinoDefault value (in case the  value is missing)n      !n      ! 1132444444419 None$&',./145678=>?@ACHMPSUVXk#,Bdino'Collect all assertions in an expression%Note that the wrapped interpretation e: must have instances of intensional classes in order for By to derive instances of HOS classes. In order for the wrapped interpretation to do monadic evaluation, use the wrapper W/ to obtain the necessary intensional instances.HdinoInterpretation wrapper whose  instance uses KdinoInterpretation wrapper whose  instance uses WdinosInterpretation wrapper that evaluates using a variable environment rather than piggybacking on higher-order syntaxW lacks instances of HOS classes. Instead, it provides instances of 'intensional classes. In order to regain the missing HOS instances, W 'can be wrapped in j.j (W e) is essentially equivalent to e, when e is a ).The purpose of W3 is to be used when evaluation must be done under jG. For example, this happens when combining reification and evaluation.ZdinoExpression reified as an ]dino(Generic representation of numbers using C`dinoIntensional counterpart of adinoIntensional counterpart of bdinoIntensional counterpart of cdinoIntensional counterpart of ddinoIntensional counterpart of edinoIntensional counterpart of fdinoIntensional counterpart of gdinoIntensional counterpart of hdinoNamed variable expressionsxThis class is only used to internally to create intensional interpretations. It should not be exposed to the EDSL user.idinoCreate a named variablejdino;Allow intensional interpretation of higher-order constructsjf is used to obtain instances of HOS classes from their intensional counterparts. For example, given ( e, h e, f e) , we get  (j e)."Pairing the interpretation with a mh allows generating symbolic variables to inspect higher-order constructs rather than just running them.mdinoTRepresentation of the set of variables used by bindings in an expression. An entry (v, n) means that the base name v: is used possibly appended with a number that is at most n.WSince the keys represent variable base names, they are not allowed to end with digits.ndinoProduct of two interpretations|The product is used to run two interpretations in parallel. Note that there are no instances for HOS classes. Instead, use j (e1 :: e2)C in order to derive an interpretation of HOS classes for products.rdinoN-ary folding functionssdinos e (*)2 returns an n-ary function of the following form: ;\(Fold a) (Fold b) ... (Fold x) -> Fold (e * a * b * ... x)(here *J denotes any binary operator, and it's assumed to be right- associative.)tdinoA folding interpretation>Instances of expression classes work by monoidal folding over e (see y).wdinoPure evaluationxdinoFunctorial evaluationCan, for example, have the type x ::  A a -> A aydino@y1 returns an n-ary function of the following form: C\(Fold a) (Fold b) ... (Fold x) -> Fold (mempty <> a <> b <> ... x)where  and  are the methods of the 9 class.~dino7Return an unused variable name from the given base name The returned m includes the new variable.dino2Open up a binder represented as a Haskell functionUThis function helps creating intensional interpretations of higher-order constructs.dino A version of  for 2-argument functionsdinoAdd a local variable bindingdino!Ignoring assertion for efficiencydino!Ignoring assertion for efficiencydino!Ignoring assertion for efficiencydino!Ignoring assertion for efficiencydino!Ignoring assertion for efficiencydino!Ignoring assertion for efficiencydinoIgnoring assertiondinoInterprets all branchesdinoInterprets all branchesdino5Integers are show exactly, non-integers are shown at = precision.dinoIgnores the assertiondinoField name prepended with #(dinoThrows T4 when variable is not in scope or has the wrong type+dinoThrows N in the underlying monad,dinoThrows N in the underlying monad adino Variable namedinoBody (open term)cdino Variable namedinoBody (open term)ddinoName of element variabledinoPredicate body (open term)edinoName of state variabledinoName of element variabledino#Body (term with two free variables)gdino Variable namedino Result when  (open term)idino Variable namedinoVariable base namedino'Body parameterized by its free variabledino$Generated variable and function bodydinoVariable base namedino(Body parameterized by its free variablesdino%Generated variables and function bodydino Variable namedinoValue of variabledino.Expression to evaluate in modified environmentHBCDEGFHIJKLMNPOSRQTUVWXYZ[\]^_`abedcfghijklmnoqprstuvwxyz{|}~Hwxtuvrsynoqpz{|}m~jklhifgbedc`a]^_Z[\WXYTUVNPOSRQKLMHIJEGFBCD None$&',./145678=>?@ACHPSUVXk&n #$ %&' ()*+  ,-./01S23! "4xytswuonvqpr5XVWU67T89:;HK<=>?@AIJBNOPCDEFLMGQRYZ[\]^_`abcdefghijklmz{|}~       !None$&',./145678=>?@ACHPSUVXk7 dino Check each assertEqE assertion by structurally comparing the ASTs of the two expressions<This limited form of formal verification is useful two ways:It can be used to verify refactorings that don't affect the AST; for example, introducing a meta-level helper function (i.e. a normal Haskell function).'When the ASTs do differ, the resulting d will show only the parts of the expressions where the difference occurs, which can make it easier to manually verify equivalence.dinoPresent the output of A as a list of test cases that either succeed or fail with a diff             ! " # $ % & ' ( ) * +, - . / 0 1 2 3 4 5 6 7 8 9 :; <= > ? @ A B :C DE F <G H IJ KL M NO PQ RS TU V W XY Z[ Z\ Z] Z^ Z_`ab cd Ze f Zg Zh ij Zk Zl cm cn Zo ip iq Zr Zs Zt u Iv Iw Tx Py Pz P{ P| } ~             N N N N N N N N N N N N N N N N N i D D D D  < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < <               I I I I I I                                                : !""#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~T""      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcddefghiijkklmnopqrstuvvwxxyzz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  dino-0.1-6MkCTG92eXJDyeFPmd1P4Q Dino.Prelude Dino.PrettyDino.AST Dino.AST.Diff Dino.TypesDino.ExpressionDino.InterpretationDino.VerificationDinobaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip System.IOprint Data.Tuplefstsnd otherwisemap$GHC.Num fromInteger-GHC.Real fromRationalGHC.EnumenumFrom enumFromThen enumFromToenumFromThenTonegatefail>>=>>fmapreturn Data.String fromString realToFrac toInteger toRational<>memptymappendmconcatjoin<*>pure*>BoundedEnum GHC.ClassesEq GHC.FloatFloating FractionalIntegralMonadFunctorNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShowData.Typeable.InternalTypeable Applicative Data.FoldableFoldableData.Traversable Traversable GHC.TypeLits KnownSymbolGHC.OverloadedLabelsIsLabel SemigroupMonoid GHC.RecordsHasField GHC.TypesBoolCharDoubleFloatInt integer-gmpGHC.Integer.TypeInteger GHC.MaybeMaybeOrderingRationalIOWord Data.EitherEitherSymbolFalseNothingJustTrueLeftRightLTEQGTStringShowSshow fromLabelsequencemapM sequenceAtraversereadIOreadLn appendFile writeFilereadFileinteract getContentsgetLinegetCharputStrLnputStrputCharGHC.IO.ExceptionioErrorGHC.IOFilePath userErrorIOErrornotElem concatMapconcat sequence_mapM_productsumminimummaximumelemlengthnullfoldl1foldr1foldlfoldrfoldMap Data.OldListunwordswordsunlineslines Text.Readreadreadseitherlex readParenreadList readsPrecText.ParserCombinators.ReadPReadSatanhacoshasinhtanhcoshsinhatanacosasintancossinlogBase**sqrtlogexppiatan2isIEEEisNegativeZeroisDenormalized isInfiniteisNaN scaleFloat significandexponent encodeFloat decodeFloat floatRange floatDigits floatRadix Data.Functor<$>lcmgcd^^^oddevendivModquotRemmoddivremquotrecip/maxBoundminBoundfromEnumtoEnumpredsucc showParen showStringshowCharshowsshowList showsPrecunzip3unzipzipWith3zipWithzip3!!lookupreversebreakspansplitAtdroptake dropWhile takeWhilecycle replicaterepeatiteratescanr1scanrscanl1scanlinitlasttailheaduncurrycurrysubtractsignumabs*+asTypeOfuntil$!flip.constid=<<<$<*GHC.Err undefinederrorWithoutStackTraceerrorcompare text-1.2.3.1Data.Text.InternalText'hashable-1.2.7.0-2SI038axTEd7AEZJ275kpiData.Hashable.ClassHashableFieldunField Importance Unimportant Important unchanged emphasize underHeader verticalList prettyRecord$fHashableImportance$fSemigroupImportance $fPrettyField $fShowField$fEqImportance$fShowImportance$fGenericImportance $fEqField $fOrdField$fIsStringField$fHashableField Inspectableinspect GInspectablegInspectGInspectableFieldsgInspectFieldsGInspectableArgs gInspectArgsASTNumberAppLetRecordConstrTupleListNamedNameType ConstructorLocalVar AnnotationMappingrecord prettyNamedinspectListAsRectoTreeshowTreedrawTreehtmlTree$fPrettyMapping$fHashableMapping$fHashableNameType$fHashableConstr$fIsStringConstr $fPrettyAST $fHashableAST$fGInspectableArgsk:*:$fGInspectableArgskU1$fGInspectableFieldsk:*:$fGInspectableFieldskU1$fGInspectablekM1$fGInspectablekM10$fGInspectablekM11$fGInspectablek:+:$fInspectable(,,,)$fInspectable(,,)$fInspectable(,)$fInspectableMapping$fInspectable[]$fInspectableMaybe$fInspectableText$fInspectable[]0$fInspectableBool$fInspectable()$fInspectableAST$fInspectableDouble$fInspectableFloat$fInspectableInteger$fInspectableInt$fInspectableRatio$fGInspectableFieldskM1$fGInspectableArgskM1 $fEqMapping $fShowMapping$fFoldableMapping$fFunctorMapping$fTraversableMapping$fGenericMapping $fEqNameType$fShowNameType$fGenericNameType$fEnumNameType$fBoundedNameType $fEqConstr $fShowConstr$fGenericConstr$fEqAST $fShowAST $fFoldableAST $fFunctorAST$fTraversableAST $fGenericASTDiffableDiffdiff applyDiff Monolithic unMonolithicEdit ReplacementEditAppEditListEditLet EditRecordListOpEndOpAppendDropEndElemOpAddElem RemoveElemEditElemReplaceoriginalnewdropEnd applyDiffWhenprettyEditTuple prettyEditApp printEditdiffAsTestResult$fPrettyReplace$fDiffable(,,) $fDiffable(,)$fDiffableMonolithic$fDiffableRatio$fDiffableDouble$fDiffableFloat$fDiffableInteger $fDiffableInt$fDiffableText$fDiffableBool $fDiffable()$fPrettyListOp $fDiffableAST $fDiffable[] $fPrettyEdit$fDiffableMapping$fDiffableMaybe $fEqReplace $fShowReplace$fFunctorReplace $fEqEndOp $fShowEndOp$fFunctorEndOp$fEqEdit $fShowEdit $fShowListOp $fEqListOp $fShowElemOp $fEqElemOpDinamicDinoType dinoTypeRep DinoTypeRepListTypePairType OtherTypeBuiltInwithType listTypeElem fromDinamic $fDinoType(,) $fDinoType[]$fDinoTypeMaybe$fDinoTypeText$fDinoTypeDouble$fDinoTypeFloat$fDinoTypeInteger $fDinoTypeInt$fDinoTypeRatio$fDinoTypeBool $fDinoType()$fTestEqualityTYPEDinoTypeRepOptionalReturnBindExpunExp AssertExpassertassertEqAnnExpannFieldExpgetFieldLetExpletETupleExppairfstEsndEListExpmapE dropWhileEfoldE ListExpFOrangelistheadEappendCondExpmaybe CondExpFOjustcases partial_cases Otherwise:-> CompareExpeqneqltgtltegteminmaxLogicExpnotconjdisjxorFracExpfdivNumExpaddsubmulabsEsignE fromIntegralfloortruncateroundNConstExplittruefalsetextfromInt./&&||==/=<><=>===!-->default_partial_casesnothingisJustmatch matchConstmatchConstFull ifThenElse fromMaybesharesharedfield<.sumEandEorEallEanyEfind<++>andorallanysupposeoptional runOptional fromOptional$fBifunctor:->$fIsLabelf1Field $fIsLabelf->$fFractionalExp$fNumExp $fIsStringExp$fMonadOptional$fApplicativeOptional$fFunctorOptional$fEq:-> $fShow:-> $fFoldable:-> $fFunctor:->$fTraversable:->$fEqExp $fShowExp $fFunctorExp$fApplicativeExp $fMonadExp $fConstExpExp $fNumExpExp $fFracExpExp $fLogicExpExp$fCompareExpExp$fCondExpFOExp $fCondExpExp$fListExpFOExp $fListExpExp $fLetExpExp $fFieldExpExp $fAnnExpExp$fAssertExpExpCollectAssertionsunCollectAssertions AssertionAssertAssertEqAssertViaMonadThrowunAssertViaMonadThrowAssertViaMonadErrorunAssertViaMonadErrorInvalidAssertionInvalidConditionNotEqualassertionLabel referenceactual EvalEnvError NotInScope TypeErrorEvalEnv unEvalEnvReified unReifiedNumRepunNumRepLetIntensionalletIListIntensionalmapI dropWhileIfoldICondIntensionalmaybeIVarExpvarE Intensional unIntensionalBindSet:×:prodFstprodSndFoldNfoldNFoldfoldevalevalF foldMonoidmkProdliftProd liftProd2 liftProd3freshVarliftIntensionalliftIntensional2liftIntensional3unbindunbind2 appReified appReified2 appReified3 appReified4 appReified5 extendEnv$fAssertExpWriterT$fAnnExpTYPEannWriterT$fFieldExpWriterT$fLetExpWriterT$fTupleExpWriterT$fListExpWriterT$fListExpFOWriterT$fCondExpWriterT$fCondExpFOWriterT$fCompareExpWriterT$fLogicExpWriterT$fFracExpWriterT$fNumExpWriterT$fConstExpWriterT$fAssertExpReaderT$fAnnExpTYPEannReaderT$fFieldExpReaderT$fLetExpReaderT$fTupleExpReaderT$fListExpReaderT$fListExpFOReaderT$fCondExpReaderT$fCondExpFOReaderT$fCompareExpReaderT$fLogicExpReaderT$fFracExpReaderT$fNumExpReaderT$fConstExpReaderT$fAssertExpExceptT$fAnnExpTYPEannExceptT$fFieldExpExceptT$fLetExpExceptT$fTupleExpExceptT$fListExpExceptT$fListExpFOExceptT$fCondExpExceptT$fCondExpFOExceptT$fCompareExpExceptT$fLogicExpExceptT$fFracExpExceptT$fNumExpExceptT$fConstExpExceptT$fAssertExpEither$fAnnExpTYPEannEither$fFieldExpEither$fLetExpEither$fTupleExpEither$fListExpEither$fListExpFOEither$fCondExpEither$fCondExpFOEither$fCompareExpEither$fLogicExpEither$fFracExpEither$fNumExpEither$fConstExpEither$fAssertExpMaybe$fAnnExpTYPEannMaybe$fFieldExpMaybe $fLetExpMaybe$fTupleExpMaybe$fListExpMaybe$fListExpFOMaybe$fCondExpMaybe$fCondExpFOMaybe$fCompareExpMaybe$fLogicExpMaybe$fFracExpMaybe $fNumExpMaybe$fConstExpMaybe$fAssertExpIdentity$fAnnExpTYPEannIdentity$fFieldExpIdentity$fLetExpIdentity$fTupleExpIdentity$fListExpIdentity$fListExpFOIdentity$fCondExpIdentity$fCondExpFOIdentity$fCompareExpIdentity$fLogicExpIdentity$fFracExpIdentity$fNumExpIdentity$fConstExpIdentity$fAssertExpDinoTypeRep$fAnnExpTYPEannDinoTypeRep$fFieldExpDinoTypeRep$fLetExpDinoTypeRep$fTupleExpDinoTypeRep$fListExpDinoTypeRep$fListExpFODinoTypeRep$fCondExpDinoTypeRep$fCondExpFODinoTypeRep$fCompareExpDinoTypeRep$fLogicExpDinoTypeRep$fFracExpDinoTypeRep$fNumExpDinoTypeRep$fConstExpDinoTypeRep$fAssertExpFold $fLetExpFold $fListExpFold $fCondExpFold$fCondExpFOFold$fAnnExpTYPEannFold$fFieldExpFold$fTupleExpFold$fListExpFOFold$fCompareExpFold$fLogicExpFold $fFracExpFold $fNumExpFold$fConstExpFold$fApplicativeFold $fFoldN->e $fFoldNFolde$fAssertExp:×:$fAnnExpTYPEann:×:$fFieldExp:×:$fTupleExp:×:$fListExpFO:×:$fCondExpFO:×:$fCompareExp:×:$fLogicExp:×: $fFracExp:×: $fNumExp:×:$fConstExp:×:$fVarExpIntensional $fVarExp:×: $fVarExpFold$fCondExpIntensional$fCondIntensional:×:$fCondIntensionalFold$fListExpIntensional$fListIntensional:×:$fListIntensionalFold$fLetExpIntensional$fLetIntensional:×:$fLetIntensionalFold $fShowNumRep$fLetIntensionalReified$fListIntensionalReified$fCondIntensionalReified$fVarExpReified$fAssertExpReified$fAnnExpTYPETextReified$fFieldExpReified$fTupleExpReified$fListExpFOReified$fCondExpFOReified$fCompareExpReified$fLogicExpReified$fFracExpReified$fNumExpReified$fConstExpReified$fInspectableReified$fLetIntensionalEvalEnv$fListIntensionalEvalEnv$fCondIntensionalEvalEnv$fVarExpEvalEnv$fExceptionEvalEnvError$fExceptionInvalidAssertion$fAssertExpAssertViaMonadError$fAssertExpAssertViaMonadThrow$fAssertExpCollectAssertions$fEqFold $fShowFold $fFunctorFold$fSemigroupFold $fMonoidFold$fConstExpIntensional$fNumExpIntensional$fFracExpIntensional$fLogicExpIntensional$fCompareExpIntensional$fCondExpFOIntensional$fListExpFOIntensional$fTupleExpIntensional$fFieldExpIntensional$fAnnExpIntensional$fAssertExpIntensional $fEqNumRep $fOrdNumRep $fNumNumRep$fFractionalNumRep $fRealNumRep$fHashableNumRep$fFunctorEvalEnv$fApplicativeEvalEnv$fMonadEvalEnv$fMonadReaderEvalEnv$fConstExpEvalEnv$fNumExpEvalEnv$fFracExpEvalEnv$fLogicExpEvalEnv$fCompareExpEvalEnv$fCondExpFOEvalEnv$fListExpFOEvalEnv$fTupleExpEvalEnv$fFieldExpEvalEnv$fAnnExpEvalEnv$fShowEvalEnvError$fShowInvalidAssertion$fFunctorAssertViaMonadError $fApplicativeAssertViaMonadError$fMonadAssertViaMonadError$fMonadErrorAssertViaMonadError$fConstExpAssertViaMonadError$fNumExpAssertViaMonadError$fFracExpAssertViaMonadError$fLogicExpAssertViaMonadError$fCompareExpAssertViaMonadError$fCondExpFOAssertViaMonadError$fCondExpAssertViaMonadError$fListExpFOAssertViaMonadError$fListExpAssertViaMonadError$fTupleExpAssertViaMonadError$fLetExpAssertViaMonadError$fFieldExpAssertViaMonadError$fAnnExpAssertViaMonadError$fFunctorAssertViaMonadThrow $fApplicativeAssertViaMonadThrow$fMonadAssertViaMonadThrow$fMonadThrowAssertViaMonadThrow$fConstExpAssertViaMonadThrow$fNumExpAssertViaMonadThrow$fFracExpAssertViaMonadThrow$fLogicExpAssertViaMonadThrow$fCompareExpAssertViaMonadThrow$fCondExpFOAssertViaMonadThrow$fCondExpAssertViaMonadThrow$fListExpFOAssertViaMonadThrow$fListExpAssertViaMonadThrow$fTupleExpAssertViaMonadThrow$fLetExpAssertViaMonadThrow$fFieldExpAssertViaMonadThrow$fAnnExpAssertViaMonadThrow$fConstExpCollectAssertions$fNumExpCollectAssertions$fFracExpCollectAssertions$fLogicExpCollectAssertions$fCompareExpCollectAssertions$fCondExpFOCollectAssertions$fCondExpCollectAssertions$fListExpFOCollectAssertions$fListExpCollectAssertions$fTupleExpCollectAssertions$fLetExpCollectAssertions$fFieldExpCollectAssertions$fAnnExpCollectAssertions$fVarExpCollectAssertionsverifyAssertEqStructurally#presentStructuralVerificationAsDocspresentStructuralVerificationcontainers-0.6.0.1 Data.TreeTreeData.Type.Equality testEqualityRefl(exceptions-0.10.1-DdWfqA1lutT4wybeL2xRnxControl.Monad.Catch MonadThrow mtl-2.2.2Control.Monad.Error.Class MonadError