úÎP¾Cuë      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦ § ¨ © ª « ¬ ­ ® ¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ü Ý Þ ß à á â ã ä å æ ç è é ê None059:;<=?DQRT[‹Data type for an error context, holding the expression where the error occurred, the environment when it did, and the error itself.^A stack of expressions leading the the expression that caused the error as the final element.-The environment's state at the time of error.The error that occurred. 1The inference context, has a similar function to  #The inference error representation. /Get a typing context from an inference context. $A typeclass for typechecking terms (term) with a typesystem (t).>The typing context, in type theory this is usually shown as Öª.ÿFor a basic typechecker of the simply-typed lambda calculus this might contain a mapping of variable and constant names to their types. This is left to be defined for the implementer though as other typesystems might need extra information in their contexts.The type error representation.„Given a typing context, typecheck an expression and either return a typeerror or the type of the expression that was passed.VTypechecking type, uses the TypingContext as state and TypeError as an exception type.GErrorContext but the environment is assumed to be the TypingContext of t.Throw an error in an .Throw a list of errors in 's.uIf there have been any errors, add the given expression to the head of all the error contexts' expression stacks.IA validation semigroup on Eithers, combining Left values when two appear.runs a  action     None05<=?DQRT[ TGiven a graph, generate a possibly empty list of subgraphs that are the it's cycles.!.Returns true if a list has more than 1 element"\Returns true if a list of contexts has more than one element or a loop in it's only element.#EBuild a graph with no edges from a foldable container of node values.$sA version of topsort that returns cycles as groups rather than incorperating them into it's result arbitrarily.·It's result is a list of eithers, with Left values representing cycles and Right values as nodes not within a cycle, in an order similar to what is given by a regular topsort.%0Convert a tree into a list of all of it's paths.&XBuild a topsort inclusive of outward edges. Nodes without outward edges are ignored.6If there are cycles in the graph, Nothing is returned.'&$ but doesn't check for cycles first. The stateful fold functionThe initial stateThe graph to traverseThe initial context5The resulting tree of values and states at each node. !"#$%&'  !"#$%&'  !"#$%&'  !"#$%&'None05<=?DQRT[ (3A simple, typed lambda calculus AST with constants.)A reference to a variable.*3A constant value, such as literals or constructors.+,An application of one expression to another.,EA lambda expression, with a variable definition and a function body.3Name-related errors, for when there's a variable, type or constant that doesn't appear in the environment that was given to the typechecker.4#A type appears that is not in scope5'A variable appears that is not in scope6'A constant appears that is not in scope9 Given the contents of a let expression's declarations, generate a graph showing the dependencies between each declaration, including recursion as loops.:9- but also return the internally used NodeMap.;!Unlet non-cyclic let expressions.<0Find all the unbound variables in an expression.()*+,123456789:;,The list of declarations in a let expressionThe body of the let declaration4Either a list of cyclic lets or the final expression<=>(+*,)3456789:;<()*+,7<34568;9: ()*+,123456789:;<=>None05<=?DQRT[B=Type errors that can occur in a simply-typed lambda calculus.C\Attempted to split a type (a -> b) into (Just (a, b)), but the type wasn't a function type.DOThe first type was expected during typechecking, but the second type was found.EA simple typing context.G A mapping of variables to types.H A mapping of constants to types.IAll the base types in scope.QiTypeclass based off simply-typed lambda calculus + a method for getting all the base types in a type.RNThe representation of a Mono type, also sometimes referred to a type constant.in the type expression A !’ M, both A and MF are mono types, but in a polymorphic type expression such as  " a. a !’ X, a is not a mono type.SsGiven two types, generate a new type representing the type of a function from the first type to the second. S K D = (K !’ D)When polymorphism is present: S (" a. a) T = (" a. a !’ T) S a t = (a !’ t)TlGiven a function type, decompose it into it's argument and return types. Effectively the inverse of S but returns ë% when the type isn't a function type. T (K !’ D) = Just (K, D) T (K) = NothingWhen polymorphism is present: T (" a. a !’ T) = Just (" a. a, t) T (a !’ T) = Just (a, t)T is almost the inverse of S., and the following property should hold true:*fmap (uncurry abstract) (reify t) = Just tULGiven a type, return a set of all the base types that occur within the type. U (" a. a) = Set.singleton (a) UZ (M X !’ (X !’ Z) !’ M Z) = Set.fromList [M, X, Z] -- or Set.fromList [M, X, Z, !’], dependingVuPolymorphic constructor synonym, as many implementations will have a constructor along the lines of "Mono m".WÿType equivalence, for simple typesystems this might be `(==)` but for polymorphic or dependent typesystems this might also include alpha equivalence or reducing the type expressions to normal form before performing another equivalence check.[Infix W.\Infix S with the appearence of !¦D, which is used to denote function types in much of mathematics.]Find the depth of a type. ] (M !’ X) = 1 ] ((M !’ Y) !’ X) = 2 ] (M !’ ((Y !’ Q) !’ Z) !’ X) = 2 ] X = 0^‚given a function that prettyprints base types, pretty print the type with function arrows whenever a function type is present._*Check if a simple type is a function type.`&Check if a simple type is a base type.aIFunction retrives a set of all base types in the given lambda expression.bXGet a typing environment that assumes all the base types in an expression are valid.BCDEFGHIQRSTUVWXYZ[\]^_`abBCDEFGHIQRSTUVWXYZ[\]^_`abQRSTUVW[\]EFGHIBCDZYX^_`abBCDEFGHIQRSTUVWXYZ[\]^_`ab[4\7None05<=?DQRT[c1Typesystems which can have values in their types.d<A value-level term that can be encoded as a type expression.Of kind * -> *0 because it expects a typesystem as a parameter.e”Encode a value at the type-level. This could be just a constructor or a complete transformation of the AST, but this typeclass doesn't care.cdecdecdecdeNone05:<=?DQRT[fRTypeclass for higher-order types. Classically this would just be checking the  #https://en.wikipedia.org/wiki/Arityarity± of type constructors but there are more complex typesystems that exist that could benefit from allowing an arbitrary typechecking ability for a higher-order typesystem.g6The typesystem for the kindedness of type expressions.hEA typing context for the kindedness of type expressions. Analogue to .i@Type errors for the kindedness of type expressions. Analogue to .jTypecheck a type expression.kMore generalised form of S@ to work on all type operators, not just function types. k M ("a. a) = (" a. M a) k T X = (T X) k (k ((!’)) A) B "a S A BlMore generalised form of T", working on all type application. l (M x) = Just (M, x) l (X !’ Y) = Just (((!’) X), Y) l X = NothingmInfix k.fghijklmfghijklmfghijklmfghijklmm8None/059:;<=?DQRT[nA TypingContextp|The substitutions made so far, where the key is the poly type that is substituted and the value is what is substituting it.qDAn infinite list of polytypes not present in the who typing context.t/Class of typesystems that exhibit polymorphism.uGThe representation of a poly type, also reffered to as a type variable.v–Find the substitutions between two type expressions. If there's a mismatch in structure then report the values passed as a Left value. Behaviour3A substitution of a poly type "a" for mono type "X"substitutions (X) (a)Right [Substitution (X) (a)]:Two type expressions have substitutions between eachother.substitutions (a !’ B) (X !’ b)2Right [Substitution (X) (a), Substitution (B) (b)]-A mutual substitution between two poly types.substitutions (a) (b)Right [Mutual (a) (b)]Mismatches in structure.substitutions (X) (Y) Left [(X, Y)]substitutions (C !’ x C) (x C)Left [(C !’ x C, x C)]wìSubstitution application, given one type expression substituting a poly type and a target type expression, substitute all instances of the poly type in the target type expression with the type expression substituting it. Behaviour)Substituting all instance of "a" with "X"(applySubstitution X a (" a b. a !’ b !’ a)(" b. X !’ b !’ X)@FSubstitution application in a type expression with a type constructor.!applySubstitution (X !’ Y) x (M x) (M (X !’ Y))kApplying a substitution to a type expression that doesn't contain the poly type being substitutedapplySubstitution Y x (M Q)(M Q)x7Quantify instances of a poly type in a type expression. Behaviour:Quantifying a poly type that appears in a type expression.quantify a (a !’ X) (" a. a !’ X)@Quantifying a poly type that doesn't appear in a type expressionquantify a (b !’ X) (" a. b !’ X)yuPolymorphic constructor synonym, as many implementations will have a constructor along the lines of "Poly p".zOFunction that retrives all the poly types in a type, quantified or not. Behaviour8Type expression with some of it's poly types quantified.!polytypesOf (" a b. a !’ b !’ c d))Set.fromList [a, b, c, d].Type expression with no quantified poly types.polytypesOf (a !’ b !’ c)Set.fromList [a, b, c]0Type expression with no unquantified poly types.polytypesOf (" c. X !’ c)Set.singleton (c){RFunction that retrives all the quantified poly types in a type expression. Behaviour8Type expression with some of it's poly types quantified."quantifiedOf (" a b. a !’ b !’ c d))Set.fromList [a, b].Type expression with no quantified poly types.quantifiedOf (a !’ b !’ c) Set.empty0Type expression with no unquantified poly types.quantifiedOf (" c. X !’ c)Set.singleton (c)|n- but assumes the poly type representation of t is the second argument.}8Datatype describing possible substitutions found by the v" Polymorphic typeclass method.~9Two equivalent polytypes that could substitute eachother."A substitution of type expression t over polytype p‚Infix ˆƒInfix x, looks a bit like "6 but doesn't interfere with unicode syntax extensions.ì/All the unbound polytypes in a type expression.„!Bound polytypes of an expression.…Monotypes of a type expression.†dQuantify every free polytype in a type expression, excluding a set of polytypes to not quantify.generalise Set.empty (x !’ y)(" x y. x !’ y),generalise (Set.fromList [a, b]) (a !’ b !’ c)(" c. a !’ b !’ c)‡†! but with an empty exclusion set.ˆóCheck if two types are equivalent, where equivalence is defined as the substitutions being made being symbolically identical, where binds and poly types appear in the same place but may have different names (this is Alpha Equivalence).,areAlphaEquivalent (" a. X !’ a) (" z. X !’ z)True"areAlphaEquivalent (M !’ X) (M !’ X)True(areAlphaEquivalent (" a. a) (" z. z !’ z)False‰/Tests if a type expression is a base poly type.isPolyType (" a. a)FalseisPolyType (a)TrueisPolyType (b !’ c)FalseŠ;Note: only shows the first 10 elements of the infinte list.nopqtuvwxyz{|}~€‚ƒì„…†‡ˆ‰Šnopqtuzvwxy{|}~€‚ƒ„…†‡ˆ‰tuvwxyz{}~ˆ‚ƒ†‡z„…‰nopq|€nopqtuvwxyz{|}~€‚ƒì„…†‡ˆ‰Š‚4ƒ6None05<=?DQRT[Ž¿A substitution conflict's root, with a tree of types substituting variables as the first element [1] and the second element being the type where these clashing substitutions converge. 1to be read that the first element of the tuple is a forest of substitutions leading the final type expression with a substitution conflict.!TODO: Put a diagram here instead.!Errors in poly type substitution.A Ž of substitutions leading to p‘"There is a cycle of substitutions.’OA substitution between two incompatable type expressions was attempted. (i.e. v (X) (Y !’ Y))ív? but takes place in an Either that catches substitution errors.“ This module's namesake function. <https://en.wikipedia.org/wiki/Unification_(computer_science) Unificationá is an important step of typechecking polymorphic lambda calculi, taking two type expressions and computing their differences to produce a sequence of substitutions needed to make both type expressions equivalent.ÿThis implementation computes a list of substitutions with the substitutions to be applied first at the end of the list and the ones to be applied last at the beginning. This is an artifact of how the reordering of the substitutions works and can be remedied with a î if needed. Behaviour(Unifying two compatable type expressionsunify (forall a. a) (A !’ B)Right [(A !’ B, a)]Aunify (forall a b c. a !’ (b !’ c) !’ a) (forall x. x !’ (I !’ x) !’ G)&Right [(G, a), (G, c), (G, x), (I, b)]5Unifying incompatable type expressions yeilds errors. unify (A) (B)Left [SubsMismatch A B]vUnifying a poly type with a type expression that contains that poly type yeilds a cyclic substitution error.unify (a) (F a)<Left [CyclicSubstitution (mkGraph [(2,(F a))] [(2,2,(a))])]]^-- The above is a graph showing the cycle of (F a) trying to substitute it's own poly type (a)8Unifying equivalent type expressions yeilds empty lists.)unify (forall a. a !’ C) (forall x. x !’ C)Right []unify (X !’ Y) (X !’ Y)Right []”“ with ï as the instance for DynGraph.ðPartition a list of }]s into it's mutuals (first element of the tuple) and it's substitutions (second element).•DTest to see if two types have valid substitutions between eachother.–wGiven a list of substitutions, resolve all the mutual substitutions and return a list of substitutions in the form (t, p).—_Type ordering operator, true if the second argument is more specific or equal to the first. BehaviourIA type expression with poly types being ordered against one without them.(" a. a) "‘ (X !’ Y)TrueGA type expression being ordered against itself, displaying reflexivity.(X !’ X) "‘ (X !’ X)TruerAll type expressions are more specific than a type expression of just a single (bound or unbound) poly type. (a) "‘ (a)True (a) "‘ (b)True (a) "‘ (X)True (a) "‘ (X !’ Y)Trueetc.˜ Non-unicode "‘.™VFor a given list of substitutions, either find and report inconsistencies through Y or compute a topsort by order of substitution such that for a list of substitutions  [a, b, c]% c should be applied, then b, then a.¡This backward application is a product of how the graph used to compute the reordering is notated and how topsorting is ordered. In this graph for nodes N, M and egde label p,  N --p-> M# notates that all instances of p in M will be substituted by N). In regular topsort this means that N will preceed MT in the list, but this doesn't make sense when we topsort to tuples of the form (N, p).š A version of ™I that takes an already generated graph rather than building it's own.¢If given a graph with cycles or nodes with 2 or more inward edges of the same label then there's no garuntee that the substitutions will be applied correctly.›—Without validating if the substitutions are consistent, fold them into a single function that applies all substitutions to a given type expression.œIValidate substitutions and fold them into a single substitution function.œ using fgl's ï.ž™Function that builds a graph representing valid substitutions or reports any part of the graph's structure that would make the substitutions invalid.Ÿž using fgl's ï.  A version of ž- that works within fgl's NodeMap state monad.¡5From a graph representing substitutions of variables p in terms tx, where edges represent the origin node replacing the variable represented by the edge label in the target node.e.g. The edge (N, (x -> x), x)8 corresponds to replacing all instances of the variable x in (x -> x) with N.¢_Find all contexts with non-unique inward labels, paired with each label that wasn't unique.ñsGiven a graph, a conflicting label, and the node where the label is conflicting; branch out towards it's roots.Ž‘’í“The first type expressionThe second type expression6The result from trying to unify both type expressions.”ð•–The list of mixed (see }) substitutions.#The resulting list of substitutions—˜™š›œžŸ A list of substitutionsgA nodemap monadic action where the graph's edges are substitutions and the nodes are type expressions.¡¢ñŽ‘’“”•–—˜™š›œžŸ ¡¢“”—˜•œ›–‘’ŽžŸ ™š¡¢Ž‘’퓔𕖗˜™š›œžŸ ¡¢ñ—4˜4 None05<=?DQRT[TBCDEFGHIQRSTUVWXYZ[\]^_`abcdefghijklmnopqtuzvwxy{|}~€‚ƒ„…†‡ˆ‰Ž‘’“”•–—˜™š›œžŸ ¡¢ None/059:;<=?DQRT[¦sAn implementation of System-F, similar to haskell's own typesystems but without type-level functions beyond (!’)´/The context for Polymorphic related informationµ1The context for Simply-typed related information.¶GError sum not within Eithers because those (GHC) type errors are messy.¦§¨©ª«¯°±²³´µ¶·¸¹º»¼ÂÃÄŦ©§¨ª²³´µ¶·¸¹Â槨©ª«¯°±¼»º¶·¸¹²³´µÃÂÅĦ§¨©ª«¯°±²³´µ¶·¸¹º»¼ÂÃÄÅ None059;<=?DQRT[ÆIData type describing a type system for simply-typed lambda calculus (»!’). ÆÇÈÎÏÐÑÒÓÔÕÖÆÈÇÎÏÐ ÆÇÈÖÕÔÓÎÏÐÒÑÆÇÈÎÏÐÑÒÓÔÕÖ None059:;<=?DQRT[ÚgA data type representing the components of System-FÉ, with a parameterized higher-order typesystem k.ò A mono typeó$Explicitly stated mono type of kind  (* !’ * !’ *) for type application reasonsôA poly type, i.e. the "a" in " " a. a !’ a"õ9A binding of a poly type in a type expression, i.e. the "" a." in "" a. a"öType application.ã.Given a function arrow representation of type m>, replace all matching mono types with the function arrow.ÚòóôõöàáâãäåæçèÚãÚã Úòóôõöàáâãäåæçèö0 None05<=?DQRT[÷3SimplyTyped with mono types represented as strings.øÌSystemFOmega with mono and poly types represented as strings. type StringSFO = SFO.SystemFOmega String String (Maybe (STLC.SimplyTyped String)) | SystemF with mono and poly types represented as strings.ùLambda Cube parsec type.ú'Lambda Cube symbol wrapper for strings.ûQLambda Cube parser token wrapper, expects the token followed by 0 or more spaces.üParenthesis parser combinator.ý_Wrapper that allows preceeding whitespace before a token and then expects the input to end.þLParser for a bare variable, notated by beginning with a lowercase character.ÿMParser for a bare constant, notated by beginning with an uppercase character.`Given a type expression parser for a Polymorphic typesystem, parse a forall quantification ( " a b c. expr or forall a b c. expr>) followed by the expression parser that was passed to it.bgiven a subexpression parser, parse a sequence of subexpressions seperated by function arrows.éOA QuasiQuoter for SystemF, allowing quantification and poly types (lower case). Q[sf| forall a b. a -> b |] == quantify "a" (quantify "b" (poly "a" /-> poly "b"))êA QuasiQuoter for SimplyTyped. ;[stlc| A -> B -> C |] == mono "A" /-> mono "B" /-> mono "C" ?[stlc| (A -> B) -> B |] == (mono "A" /-> mono "B") /-> mono "B"NHelper to generate a QuasiQuoter for an arbitrary parser with a liftable type.÷øùúûüýþÿéêéêéê÷øùúûüýþÿéê !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzz{|}~€‚ƒ„…†‡ˆ‰ˆŠ‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ¼ ½ ¾ ¿ À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Í Î Ï ± ³ Ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ü Ý Þ ß à á â ã ä å æ ç è é ê ë ì í î ï ð ñòóôõöò÷øùúûüý ± þ ² ´ ÿ               (typerbole-0.0.0.5-1Whqz1EuYDxGkcWlAnaGFKControl.TypecheckableData.Graph.Inductive.HelperCalculi.LambdaCalculi.Lambda.Cube.SimpleTypeCalculi.Lambda.Cube.DependentCalculi.Lambda.Cube.HigherOrderCalculi.Lambda.Cube.Polymorphic+Calculi.Lambda.Cube.Polymorphic.UnificationCompiler.Typesystem.SystemFCompiler.Typesystem.SimplyTyped Compiler.Typesystem.SystemFOmegaCalculi.Lambda.Cube.THCalculi.Lambda.Cube ErrorContext _expression _environment_errorOfContext$fEqErrorContext$fOrdErrorContext$fShowErrorContext InferableInferenceContext InferErrorinfer typingContext Typecheckable TypingContext TypeError typecheck Typecheck ErrorContext' environmenterrorOfContext expressionthrowErrorContextthrowErrorContextsappendExprToEContexts<><> runTypecheck$fFunctorErrorContext findRootPathsfindRootPathsBytreeRootStatefulBy cyclesOfGraphcyclicSubgraphshasSomehasSome'buildFromNodestopsortWithCycles treeToPaths edgeyTopsortunvalidatedEdgeyTopsort LambdaTermVariableConstantApplyLambda$fEqLambdaTerm$fOrdLambdaTerm$fShowLambdaTerm$fDataLambdaTerm$fBifunctorLambdaTerm$fBifoldableLambdaTerm NotKnownErr UnknownTypeUnknownVariableUnknownConstantUntypedLambdaExprLetDeclrletsDependencyletsDependency'unletfreeVars$fArbitraryLambdaTerm$fBitraversableLambdaTerm$fEqNotKnownErr$fOrdNotKnownErr$fShowNotKnownErr SimpleTypeErr NotAFunctionUnexpectedTypeSimpleTypingContext _variables _constants _allTypes$fShowSimpleTypingContext$fReadSimpleTypingContext$fEqSimpleTypingContext$fOrdSimpleTypingContext$fEqSimpleTypeErr$fOrdSimpleTypeErr$fShowSimpleTypeErr SimpleTypeMonoTypeabstractreifybasesmono equivalentallTypes constants variables====/->order prettyprintST isFunctionisBase basesOfExpr envFromExpr Dependent DependentTerm valueToType HigherOrder Kindsystem KindContext KindError kindchecktypeapuntypeap/$ SubsContext _subsMade_tape$fEqSubsContext$fOrdSubsContext PolymorphicPolyType substitutionsapplySubstitutionquantifypoly polytypesOf quantifiedOf SubsContext' SubstitutionMutualsubsMadetape≣\-/boundPolytypesOf monotypesOf generalise generalise'areAlphaEquivalent isPolyType$fShowSubsContext$fEqSubstitution$fOrdSubstitution$fShowSubstitution ConflictTreeSubsErrMultipleSubstitutionsCyclicSubstitution SubsMismatchunifyunifyGrhasSubstitutionsresolveMutuals⊑\< topsortSubs topsortSubsGunvalidatedApplyAllSubs applyAllSubsapplyAllSubsGrsubstitutionGraphsubstitutionGraphGrsubstitutionGraphM occursCheck conflicts $fEqSubsErr $fShowSubsErr $fReadSubsErrSystemFMonoPolyFunctionForall $fShowSystemF $fEqSystemF $fOrdSystemF $fDataSystemF$fBifunctorSystemF$fBifoldableSystemF$fBitraversableSystemFSystemFContext_polyctx_stlcctx SystemFErr SFNotKnownErrSFSimpleTypeErr SFSubsErr$fPolymorphicSystemF$fSimpleTypeSystemF $fLiftSystemF$fEqSystemFContext$fOrdSystemFContext$fShowSystemFContext$fShowSystemFErr$fEqSystemFErrpolyctxstlcctx$fArbitrarySystemF $fTypecheckableLambdaTermSystemF SimplyTyped$fShowSimplyTyped$fReadSimplyTyped$fEqSimplyTyped$fOrdSimplyTyped$fDataSimplyTypedSimplyTypedErr STNotKnownErrSTSimpleTypeErr$fArbitrarySimplyTyped$$fTypecheckableLambdaTermSimplyTyped$fSimpleTypeSimplyTyped$fFoldableSimplyTyped$fFunctorSimplyTyped$fLiftSimplyTyped$fEqSimplyTypedErr$fOrdSimplyTypedErr$fShowSimplyTypedErr SystemFOmega$fEqSystemFOmega$fOrdSystemFOmega$fShowSystemFOmega$fReadSystemFOmega$fDataSystemFOmega$fBifunctorSystemFOmega$fBifoldableSystemFOmega$fBitraversableSystemFOmegamarkAsFunctionArrow$fArbitrarySystemFOmega$fHigherOrderSystemFOmega$fPolymorphicSystemFOmega$fSimpleTypeSystemFOmega$fLiftSystemFOmegasfstlcbaseGHC.BaseNothingfreePolytypesOfsubstitutionsMGHC.Listreverse"fgl-5.5.3.0-KO9F4uETTjy3vgLQ22ev7I!Data.Graph.Inductive.PatriciaTreeGrpartitionSubstitutionsbranchConflicts FunctionArrowTypeAp StringSTLCStringSFLCParsec lamcsymbol lamctokenparenwrappedvariableconstantquant exprsequencemkqqsfexprstlcexpr