h*۩      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                  0.6.2.0 Safe-Inferred  ")= Safe-Inferred  ")1= registry>Return true if the type of this type rep represents a functionregistry&Show the full type of a typeable valueregistry)Show the full type of a typeable functionregistryShow the full type of a typeable value where nested types like IO[Int] or functions are represented and non GHC types are shown with their module namesregistryShow the full type of a typeable value where nested types like IO[Int] or functions are represented and non GHC types are shown with their module namesregistryShow a type like m a registry:Show a single type. Don't display the module for GHC types registry+Return true if the module name can be shown registry3Tweak some standard module names for better display registryThis is an attempt to better render "nested" types like IO (Maybe Text) The input value is "IO Maybe Text" and the output text will be "IO (Maybe Text)" This will unfortunately not work with types having several type parameters like IO (Either Text Int) registry,Show a type constructor with its module name    Safe-Inferred  ")=3registryType of keys used to cache values A value can either be cached with a specific key, or it is a singletonregistryCache for a value of a single type There is at most one singleton and possibly some custom values, indexed by a specific keyregistryA cache for created values, with a map from the textual representation of a type to various cached valuesregistryCache an effectful value with a given text key so that the value is not recreated for the same keyregistry;Cache an effectful value by using its type as the cache keyregistry4An empty cached value (with no cached instances yet)registryCreate an empty cacheregistryGet the current cacheregistryMake sure that an effectful value is cached after the first evaluation for a specific keyregistryGet a cached value from the cache This is a IO operation since we access the cache MVarregistryCache a value at a given key in the cache This is a IO operation since we access the cache MVarregistry%Retrieve a cached value given its key registryInsert a (dynamic) value in the Cached data structure for a specific type of value!registry.Return the dynamic value cached at a given key"registry.Return a textual description of a Haskell type !" !" Safe-Inferred  ")=8(registryList of values available which can be used as parameters to constructors for building other values+registryA ModifierFunction modifies an already created value If that value has been created as the result of a specialization then the specialization path is also passed to the function This is used for memoizing actions using a cache so that we cache each specialized value separately.,registryList of functions modifying some values right after they have been built. This enables "tweaking" the creation process with slightly different results. Here SomeTypeRep is the target value type a and.registryFor a given context this represents the position of a specialization path in that context. startRange is the index of the start type of the specialization endRange is the index of the last type.2registryThis represents the full context in which a value has been specialized Context is the full list of types leading to the creation of that value and Specialization is a sub path describing under which types the value must be specialized For example, when creating a FilePath used by a Logger the context could be: App -> Database -> Sql -> Logger and the Specialization just Database -> Logger to specify that the file path must have a specific value in that case6registryList of consecutive types used when making a specific values See the comments on 77registryA specialization is defined by a path of types, from top to bottom in the value graph and a target value, which is the value to use when we need a value of that type on that path. For example: specializationPath = [App, PaymentEngine, TransactionRepository] specializationValue = DatabaseConfig "localhost" 5432 This means that need to use this DatabaseConfig whenever trying to find inputs needed to create a TransactionRepository if that repository is necessary to create a PaymentEngine, itself involved in the creation of the App;registrySpecification of values which become available for construction when a corresponding type comes in context>registry(The values types that a value depends onAregistry"The values that a value depends onDregistryThe types of values that we are trying to build at a given moment of the resolution algorithm. We also store the function requiring a given value type to provide better error messages IMPORTANT: this is a *stack*, the deepest elements in the value graph are first in the listGregistryThis is a list of entries in the registry available for constructing values They are sorted by output type and if there are several available functions or values for a given type the first one in the list has the highest priorityJregistryA Untyped is used for storing either a value or a function in the registryMregistryA Typed value or function can be added to a Registry It is either a value, having both  and * information or a function having just  informationPregistryDescription of a T! with input types and output typeTregistryA Function is the 7 representation of a Haskell function + its descriptionVregistryDescription of a value. It might just have a description for its type when it is a value created by the resolution algorithmZregistryA Z is the  representation of a Haskell value + its description It is either provided by the user of the Registry or created as part of the resolution algorithm.A value can simply be provided by the user of the registry or created as the result of function applicationDependencies is the transitive list of all the values used to create a CreatedValueThe optional SpecializationContext is used for values created as the result of a specialization It stores the context of creation (the list of types we are currently trying to build) and the desired specialization (which must be a subtype of the context)]registry1Describe a value with its type and actual content^registry#Describe a value with only its type_registryShow a Value from the Registry`registryCreate a Value from a Haskell value, using its Show instance for its descriptionaregistryMake a ProvidedValuebregistry,make a CreatedValue in no particular contextcregistry3Create a Value from a Haskell value, with only its  descriptiondregistryCreate a Value from a  value and some descriptioneregistryType representation of a ZfregistryDynamic representation of a ZgregistryThe description for a ZhregistryThe dependencies for a ZiregistryA ValueDescription as . If the actual content of the Z7 is provided display the type first then the contentlregistry8Return the specialization used when specializing a valuemregistryReturn True if a type is part of the specialization context of a ValuenregistryReturn True if a value has transitives dependencies which are specialized valuesoregistry Create a T value from a Haskell functionpregistry Describe a T (which doesn't have a - instance) that can be put in the RegistryqregistryShow a Function as  using its DescriptionrregistryThe Description of a TsregistryDynamic representation of a TtregistryType representation of a Turegistry(Type representation of the output of a TvregistryA P as wregistryReturn True if a T has some input parametersxregistryDrop the type variableyregistry*Return the output type of an untyped entryzregistryDynamic representation of a T{registry>Create a Entries data structure from a list of untyped entries|registry:Create a list of functions from the Entries data structure}registry7Create a list of values from the Entries data structure~registryDisplay a list of constructorsregistryDisplay a list of valuesregistryAdd one more Function to the list of Entries. It gets the highest priority for functions with the same output typeregistryAdd an entry to the list of Entries. It gets the highest priority for functions with the same output typeregistryAdd one more untyped entry to the list of Entries It gets the lowest priority for functions with the same output type This is not a very efficient because it requires a full recreation of the mapregistryAdd one more untyped entry to the list of Entries It gets the lowest priority for functions with the same output type This is not a very efficient because it requires a full recreation of the mapregistryFind a function or value returning a target type from a list of entriesregistry+Return the target types for a given contextregistry(Return the types of all the dependenciesregistry.The dependencies of a value + the value itselfregistryFor each dependency of the value Return the specialization context of the value if - that dependency value is specialized - the current value is part of the context stack and part of a context pathregistryFirst type of a specializationregistryLast type of a specializationregistry9Return the type of the replaced value in a specializationregistryA specialization is applicable to a context if all its types are part of that context, in the right orderregistryReturn the specializations valid in a given context Those are the specializations which path is a subpath of the current contextregistryThe depth of a specialization in a context is the the index of the "deepest" type of that specialization in the stack of types of that context is the one having its "deepest" type (in the value graph) the "deepest" in the current context If there is a tie we take the "highest" highest type of eachregistryIn a given context, create a value as specified by a specialization the full context is necessary since the specificationPath is only a subpath of a given creation context Note: there are no dependencies for this value since it has been directly provided by a SpecializationregistryDisplay a list of specializations for the Registry, just showing the context (a type) in which a value must be selectedregistry Create a + value from a Haskell function The application of that function does not depend on the fact that we are trying to apply it to a specialized valueregistry Create a + value from a Haskell function that will only act on unspecialized valuesregistryDisplay a list of modifiers for the Registry, just showing the type of the modified valueregistry4Create a Values data structure from a list of valuesregistryReturn values as a listregistry(Add one more Value to the list of ValuesregistryAdd one more Value to the list of Values It gets the lowest priority for values with the same type This is not a very efficient because it requires a full recreation of the mapregistryFind all the values with a specific type from a list of valuesregistryFind the first value with a specific type from a list of valuesregistryA specialization range is preferable to another one if its types are more specific (or "deepest" in the value graph) than the other If a path is limited to just one type then a path ending with the same type but specifying other types will take precedence See TypesSpec for some concrete examples.(*)+,-.10/254367:98;=<>@?ACBDFEGIHJLKMONPSRQTUVYXWZ\[]^_`abcdefghijklmnopqrstuvwxyz{|}~Z\[VYXW]^_`abcdefghijklmnTUoPSRQpqrstuvwMONJLKxyzGIH{|}~DFEACB>@?;=<7:9862543.10/,-+(*) Safe-Inferred  ")== registryA function application with an output value and a list of input valuesregistryList of distinct paths from the root of the value graph to a leafregistryA list of function applications created when creating a value out of the RegistryregistryThis datatype records: - the created values - the applied functions - the specializations used to create valuesregistry'Create Statistics from a list of valuesregistry=Return the specializations used during the creation of valuesregistryReturn the list of distinct paths from the root of a value graph to leaves of that graph. This can be used to check if a given value was indeed used according to a given specializationregistry?Return all the paths from a given value to all its dependenciesregistry4Find the most recently created value of a given typeregistry'Find the created values of a given type Safe-Inferred  ")=A registry*Monadic stack for the resolution algorithmregistry)Return a value from the Stack if possibleregistry)Return a value from the Stack if possibleregistry-Run the stack to get a list of created valuesregistryReturn the state of the stack after executing the action This returns the list of built valuesregistry5Return the list of applied functions after resolutionregistryRun the stack to get a the statistics, starting with some initially created valuesregistryGet the current list of valuesregistry"Get the current list of operationsregistry!Modify the current list of valuesregistryModify the current operationsregistryModify the current statisticsregistry6Store a function application in the list of operations   Safe-Inferred  ")=DregistryApply a function to a list of  valuesregistryApply a function modifying a single value and keeping its type to be used with Modifiersregistry4Apply a Dynamic function to a list of Dynamic valuesregistry6Apply just one dynamic parameter to a dynamic functionregistry4If Dynamic is a function collect all its input typesregistry;If the input type is a function type return its output typeregistryfunctionregistryinputsregistryresultregistryfunctionregistryinputsregistryresultregistryfunctionregistryinputsregistryresult Safe-Inferred ")1=KregistryFind a value having a target type from: - a list of "preferred values" (Specializations) to select when we are trying to find the target in a specific context (Context). Context describes the types of values we are currently trying to (recursively) make)a list of already created values (Values)3 subtleties: 1. if there are specialized values we need to find the most specialized for the current context, that is the one having its "targetType" the "lowest" in the values graph if an already created value has the right type but if it is a specialization and the type we are looking for is not in the specialization context then we cannot use that value, we need to recreate a brand new oneif an already created value has the right type and is not specialized but if there is an incompatible specialization for one of its dependencies then it cannot be usedregistryAmong all the applicable specializations take the most specific one if there exists anyregistry3Among all the created values, take a compatible one2. and 3. if that value is a specialized value or has specialized dependencies it must be compatible with the current contextregistryGiven a newly built value, check if there are modifiers for that value and apply them before "storing" the value which means adding it on top of the registry, represented by the ( state in StateT Values. We use a StateT Either because applying modifiers could fail and we want to catch and report the error. Note that this error would be an implementation error (and not a user error) since at the type-level everything should be correct  Safe-Inferred ")1=PregistryMake a value from a desired output type represented by SomeTypeRep and a list of possible constructors A D is passed in the form of a stack of the types we are trying to build so far Entries is the list of all the constructors in the Registry Specializations is a list of specific values to use in a given context, overriding the normal search Modifiers is a list of functions to apply right before a value is stored in the RegistryregistryShow the target type and possibly the constructor function requiring it for every target type in the contextregistryMake the input values of a given function When a value has been made it is placed on top of the existing registry so that it is memoized if needed in subsequent callsregistryinput types to buildregistry$current context of types being builtregistry!available entries to build valuesregistry0list of values to use when in a specific contextregistry-modifiers to apply before storing made values  Safe-Inferred  ")=VDregistry.Type alias for associating a number to a valueregistryType alias for a list of edgesregistry-Type alias for a list of an edge in the graphregistryType alias for a list of hashesregistryType alias for a ValueIdregistryType alias for a Hashregistry"List of value hashes by value typeregistryUse a State type to get the current index of a value when there are values of the same type and different hash valuesregistry A DOT graphregistryMake a list of graph edges from the list of function applicationsregistry5Make a DOT graph out of all the function applicationsregistry'Update a map classifying values by typeregistry7A DOT edge representing the dependency between 2 valuesregistryRepresent a value as a vertex in a dot graph we use some state to keep track of values of the same type The values are numbered starting from 1 when there are several of them for the same typeregistry4Return the hash of a value based on its dependenciesregistry'Description of a Value in the DOT graphregistryDon't show the counter if thereregistryWe need to process the node descriptions - we add quotes arountd the text - we remove quotes (") inside the text - we escape newlinesregistryRemove quotes from a textual description to avoid breaking the DOT formatregistryReplace n with \n so that newlines are kept in node descriptions  Safe-Inferred ")1=\registryType family for applying a function to the last type of a function typeregistryTypeclass for counting the number of arguments of a function typeregistry1Count the number of arguments for a function typeregistry-Number of arguments for a given function typeregistryApplyLast typeclass provided by @neongreen It uses an auxiliary typeclass to count the arguments of a functionregistryThe output of some constructors can be "tagged" with a string to indicate how a given value was built.registryTypeclass for lifting a function with a result of type m b into a function with a result of type n bregistryTypeclass for lifting impure functions to effectful arguments and resultsregistryTypeclass for lifting pure functions to effectful arguments and resultsregistry7Lift a pure function to effectful arguments and resultsregistry=Lift an effectful function to effectful arguments and resultsregistryLift a function returning an effectful result to a function returning another effectful resultregistry/Tag a given constructor f with a string s. The  function only applies the tag to the output type of the constructor. For example data Salary = Fixed Int | Variable Int Double tag @Variable" Variable :: Int -> Double -> Tag Variable Salaryregistry7Apply a function to the last return value of a functionregistryInstance for n argumentsregistryInstance for zero arguments  Safe-Inferred ")1=dSregistry=Type family to remove some redundant types in a list of typesregistry:Return '[a] only if it is not already in the list of typesregistryExtracted from the typelevel-sets project and adapted for the Registry datatype This union deduplicates elements only if they appear in contiguously What we really want is typelevel sets but they are too slow for now 5https://github.com/dorchard/type-level-sets/issues/17registryFrom the list of all the input types and outputs types of a registry Can we create all the output types?registryShorthand type alias when many such constraints need to be added to a type signatureregistry1Compute if a type is contained in a list of typesregistry1Compute if a type is contained in a list of typesregistryCompute if each element of a list of types is the same as another in a different orderregistryCompute if each element of a list of types is contained in another list when trying to append 2 registries together where target, is the list of inputs of the first registryregistryCompute if each element of a list of types is contained in another list when trying to add the function targetregistry6Compute if a registry can be added to another registryregistry0Compute if a function can be added to a registryregistry&Compute the output type for a functionregistry.Compute the list of input types for a functionregistryThe list of elements: a + els is a subset of out if els is a subset of out and a is also included in the set out. The search for a in out is done via a type family in order to be able to display an error message if it can't be found  Safe-Inferred ")1=q5registryTypeclass for extracting type representations out of a list of typesregistry(Singleton type representing erased typesregistryTypeclass for appending values and or registries together, without static checksregistryTypeclass for appending values and or registries together, with static checksregistryContainer for a list of functions or values Internally all functions and values are stored as 5 values so that we can access their representationregistryAppend 2 registries togetherregistryStore an element in the registry Internally elements are stored as  values The signature checks that a constructor of type a can be fully constructed from elements of the registry before adding itregistryStore an element in the registry Internally elements are stored as  valuesregistryStore an element in the registry, at the end of the registry Internally elements are stored as  valuesregistry7Add 2 typed values together to form an initial registryregistryAdd an element to the Registry but do not check that the inputs of a can already be produced by the registry8Prepend an element to the registry with no checks at allregistryMake the lists of types in the Registry unique, either for better display or for faster compile-time resolution with the make functionregistryRemove the parameters list of the registry and replace it with an empty type This makes it easier to read compilation errors where less types are being displayed On the other hand the resulting registry cannot be type-checked anymore when trying to get values out of itregistryIn case it is hard to show that the types of 2 registries align for example with conditional like if True then fun myFunctionWithKnownOutputs <: r else rregistryAnd for extreme cases where you know you're doing the right thing but can't prove itregistryThe empty Registryregistry1Create a value which can be added to the RegistryregistryCreate a value which can be added to the Registry and "lift" it to an  contextregistryCreate a "lifted" a Valueregistry4Create a function which can be added to the RegistryregistryThis is a shortcut to  fun . allTo where allTo* lifts all the inputs and output to an  contextregistryThis is a shortcut to  fun . argsTo where allTo lifts the inputs only to an  context In general  should work, even with function already returning an m a but if this is not the case (see issue #7) then funAs can be usedregistryFor a given type a being currently built when a value of type b is required pass a specific valueregistry2Specialize a function for a specific path of typesregistryOnce a value has been computed allow to modify it before storing it This keeps the same registry typeregistryOnce a value has been computed allow to modify it before storing it This keeps the same registry type This only tweaks unspecialized values!!!5545 Safe-Inferred ")1=tregistry-Make an element of type a out of the registryregistryMake an element of type a out of the registry and check statically that the element can be builtregistryMake an element of type a out of the registry, for a registry which was possibly created with +:registrymake for specialized valuesregistrymake for specialized valuesregistrymakeEither for specialized values, in case you are using an unchecked registryregistrymakeEither for specialized values along a path, in case you are using an unchecked registryregistryThis version of make only execute checks at runtime this can speed-up compilation when writing tests or in ghci Safe-Inferred ")1=}8registryThis typeclass take an existing registry and makes a singleton for each Rio output typeregistry,Registry where all Rio values are singletonsregistryThis data type provides some support for creating effectful components with resources You can use the regular MonadResource functions like allocate to make sure that resources are cleaned up You can also use the  functionregistryRun a Rio action by providing an empty cache and allocating / destroying resourcesregistryRun a Rio action by providing an empty cache and allocating / destroying resourcesregistryUse the value created by a Rio action so that resources are properly allocated and cachedregistryUse the value created by a Rio action so that resources are properly allocated and cached inside a monad transformerregistry,Run a Rio action by providing an empty cacheregistryRun a Rio action by providing an empty cache, and return the final cache for inspectionregistry!Lift a resourceful value into RioregistryThis function must be used to run services involving resources The value a is created using the registry, used with the function f* and all resources are freed at the endregistryThis function works like  for a higher-order monad, typically `PropertyT IO` when writing property tests with HedgehogregistryCreate a function of type a with a given registry Return a ResourceT value to control resource allocationregistryMake singletons for all the output types of a registry but only if they not specialized valuesregistry(Prepare a Registry for making singletonsregistryPrepare a Registry for making singletons on a specific list of typesregistryIf the type represents a pure value, make singletons for the restregistryIf the type represents an effectful value, make a singleton for it and recurse on the restregistry4If the list of types is empty there is nothing to do Safe-Inferred  ")= registry3Run some registry modifications in the StateT monadregistry8Add an element to the registry without changing its typeregistryAdd an element to the registry without changing its type *** This possibly adds untracked input types / output type! ***registryAdd an element to the registry without changing its type, in the State monadregistryAdd an element to the registry without changing its type, in the State monad *** This possibly adds untracked input types / output type! ***registryAdd an element to the registry without changing its type, in the State monadregistryAdd an element to the registry without changing its type, in the State monad *** This possibly adds untracked input types / output type! ***registry8Add an element to the registry without changing its typeregistryAdd an element to the registry without changing its type *** This possibly adds untracked input types / output type! ***registryRegister modifications of elements which types are already in the registryregistryConcatenate a registry to another statefully (to be used with $(makeGenerators ''MyType))registryRegister modifications of the registry without changing its typeregistryConcatenate 2 registries   Safe-Inferred  ")=IregistryReturn  as the result of the creation of a value of a given type (and throws an exception if the value cannot be created)registryReturn < as the result of the creation of a value of a given type Safe-Inferred  ")=registryMake a DOT graph for a specific value a built from the Registry a is at the root of the graph and its children are values needed to build aregistrySimilar to make but does not check if a can be made out of the Registry It returns a Left value if that's not the case Safe-Inferred  ")=BMNOMNO Safe-Inferred  ")= registryThese generation options can be used to tweak the generated namesregistry;Create the haskell code presented in the module descriptionregistry7Make a typeclass using some specific generation optionsregistryCreate an instance definition using a ReaderT instance instance WithLogger (ReaderT (Logger m) m) where ...registryMake the function declaration of the typeclass based on the function name in the "record of functions"registryThis produces: info p1 p2 = ReaderT (component -> _info component p1 p2)registry2count the number of parameters for a function typeregistryModify a template haskell nameregistry,Remove the module name from a qualified name Safe-Inferred  ")= !"#$%&'(()*++,-./0123456789:;<==>?@@AABCDDEFGHHIJKKLMMNOOPQQRSSTUVWXYZ[[\]^^__`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                  'registry-0.6.2.0-CZOB8JYKVaiDgtmikPwk0eData.Registry.Internal.MultiMap!Data.Registry.Internal.ReflectionData.Registry.Internal.CacheData.Registry.Internal.Types!Data.Registry.Internal.StatisticsData.Registry.Internal.StackData.Registry.Internal.DynamicData.Registry.Internal.RegistryData.Registry.Internal.MakeData.Registry.Internal.DotData.Registry.LiftData.Registry.SolverData.Registry.RegistryData.Registry.MakeData.Registry.RioData.Registry.StateData.Registry.StatisticsData.Registry.DotData.Registry.THregistry Data.RegistryPaths_registry$fMonoidMultiMap$fSemigroupMultiMap$fShowMultiMap isFunctionshowFullValueTypeshowFullFunctionTypeshowTheFullValueTypeshowTheFullFunctionType showNestedshowSingleTypemustShowModuleName tweakNestedparenthesizeNestedshowWithModuleNameKeyCustom SingletonCachedsingletonCached customCachedCachecacheAt singleton emptyCachednewCacheaskCache cacheAtKey getCached setCachedgetCachedValue cacheDynValue getDynValue makeTypeText$fEqKey $fShowKey$fOrdKey $fEqCache $fShowCachedValuesunValuesModifierFunction ModifiersSpecializationRange _startRange _endRangeSpecializationContext scContextscSpecializationSpecializationPathSpecialization_specializationPath_specializationValueSpecializationsunSpecializationsDependenciesTypesunDependenciesTypes DependenciesunDependenciesContext _contextStackEntries unFunctionsUntyped UntypedValueUntypedFunctionTyped TypedValue TypedFunctionFunctionDescription _inputTypes _outputTypeFunctionValueDescription _valueType _valueValueValue CreatedValue ProvidedValue describeValuedescribeTypeableValue showValue createValuemakeProvidedValuemakeCreatedValuecreateTypeableValuecreateDynValuevalueDynTypeRepvalueDynvalDescriptionvalueDependenciesvalDescriptionToTextvalueSpecializationContext valueContextvalueSpecializationisInSpecializationContexthasSpecializedDependenciescreateFunctiondescribeFunction showFunctionfunDescriptionfunDyn funDynTypeRepfunDynOutTypeRepfunDescriptionToText hasParametersuntype outTypeRep untypedDyn fromUntyped toFunctionstoValuesdescribeFunctionsdescribeValues addUntypedaddEntry appendUntyped appendEntry findUntyped contextTypesdependenciesTypesdependenciesOfspecializedContextsspecializationStartspecializationEndspecializationTargetTypeisContextApplicable applicableTospecializationRangecreateValueFromSpecializationdescribeSpecializationscreateConstModifierFunction#createUnspecializedModifierFunctiondescribeModifiers fromValues listValuesaddValue appendValue findValues findValue$fHashableValueDescription$fMonoidContext$fSemigroupContext$fHashableValue $fEqValue$fOrdSpecializationRange$fShowModifiers $fShowValues$fSemigroupValues$fMonoidValues$fSemigroupModifiers$fMonoidModifiers$fEqSpecializationRange$fShowSpecializationRange $fShowEntries$fSemigroupEntries$fMonoidEntries$fShowSpecializations$fSemigroupSpecializations$fMonoidSpecializations$fShowSpecializationContext$fShowSpecialization $fShowUntyped $fShowValue$fEqDependencies$fShowDependencies$fSemigroupDependencies$fMonoidDependencies$fEqDependenciesTypes$fShowDependenciesTypes$fSemigroupDependenciesTypes$fMonoidDependenciesTypes $fEqContext $fShowContext$fShowFunction$fEqFunctionDescription$fShowFunctionDescription$fEqValueDescription$fShowValueDescriptionAppliedFunction _outputValue _inputValuesPaths Operations Statistics operationsvaluesinitStatisticsvaluesSpecializationsallValuesPaths valuePathsfindMostRecentValuefindCreatedValues$fMonoidStatistics$fSemigroupStatistics$fShowStatistics$fShowAppliedFunctionStackrunStackrunStackWithValues execStackexecStackWithValues evalStackevalStackWithValues getValues getOperations modifyValuesmodifyOperationsmodifyStatisticsfunctionApplied applyFunctionapplyModificationapplyFunctionDyn applyOneParamcollectInputTypes outputTypefindValueOrSpecialization$findBestSpecializationFromApplicablefindCompatibleCreatedValue storeValue makeUntypedshowContextTargets makeInputs ValueCounterEdgesEdge ValueHashesValueIdHash ValuesByTypeDotStateDotunDot makeEdgestoDotcountValueTypes toDotEdge toDotVertexhashOfnodeDescriptionshowValueCounteradjust removeQuotesescapeNewlines$fEqDot $fShowDotApplyCNumArgsgetNA CountArgsNumArgsNAZNASNatZSTagunTagApplyVariadic2applyVariadic2ApplyVariadic1applyVariadic1 ApplyVariadic applyVariadicallToargsTooutTotag applyLast$fApplyVariadicfFUNb$fApplyVariadicffb$fApplyVariadicfab$fApplyVariadic1fFUNb$fApplyVariadic1ffb$fApplyVariadic2kfgFUNb$fApplyVariadic2kfgfb$fApplicativeTag $fFunctorTag$fCNumArgsSFUN $fCNumArgsZa$fEqTag $fShowTag Normalized FindUnique:++Solvable:- Contains1Contains IsSameSet AreSubsetIsSubset CanMakeManyCanMakeOutputInputs$fIsSubset:outt$fIsSubset[]outt$fAreSubset:outts$fAreSubset[]outts$fSolvableinsout$fIsSameSettypes1types2PathToTypeReps someTypeReps ERASED_TYPESAddRegistryUncheckedLike<+AddRegistryLike<:Registry_entries_specializations _modifiers<+>registerregisterUncheckedappendUncheckedaddTypedUnchecked+: normalize eraseTypes safeCoerce unsafeCoerceendvalvalToliftProvidedValuefunfunTofunAs specializespecializePathtweaktweakUnspecialized$fMonoidRegistry$fSemigroupRegistry$fShowRegistry#$fAddRegistryLikeTypedTypedRegistry&$fAddRegistryLikeRegistryTypedRegistry&$fAddRegistryLikeTypedRegistryRegistry)$fAddRegistryLikeRegistryRegistryRegistry,$fAddRegistryUncheckedLikeTypedTypedRegistry/$fAddRegistryUncheckedLikeRegistryTypedRegistry/$fAddRegistryUncheckedLikeTypedRegistryRegistry2$fAddRegistryUncheckedLikeRegistryRegistryRegistry$fPathToTypeReps:$fPathToTypeReps:0makemakeSafe makeEithermakeSpecializedmakeSpecializedPathmakeSpecializedEithermakeSpecializedPathEithermakeEitherWithContextMakeSingletonsmakeSingletonsSingletonsRegistry_singletonsRegistryRiorioRunrunRioexecRiowithRiowithRioMrunCache execCacheliftRio withRegistry withRegistryM runRegistryT singletonsstartSingletonsRegistrymakeSingletonsRegistry$fMakeSingletons:$fMakeSingletons:0$fMakeSingletons[] $fFunctorRio$fApplicativeRio $fMonadRio$fMonadReaderCacheRio $fMonadIORio$fMonadResourceRio$fMonadUnliftIORiorunSaddFunToaddFunToUnsafeaddFunS addFunUnsafeSaddToS addToUnsafeSaddFun addFunUnsafe addToRegistry concatUnsafeSaddToRegistryUnsafeconcatRegistryUnsafemakeStatisticsmakeStatisticsEithermakeDot makeDotEitherTypeclassOptions makeTypeclassmakeTypeclassWithbaseGHC.ShowShowData.Typeable.InternalTypeable Data.DynamicDynamic text-2.0.2Data.Text.InternalTextGHC.Base ApplicativecreateReadertInstancemakeFunctionDeclarationmakeFunctionInstancecountNumberOfParameters modifyName dropQualifiedversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDirgetDataFileName getSysconfDir