h&Y}      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                      Safe-Inferred !")1< l 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 aregistry:Show a single type. Don't display the module for GHC typesregistry+Return true if the module name can be shownregistry3Tweak 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  ")<)< 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 andregistryFor 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.registryThis 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 caseregistryList of consecutive types used when making a specific values See the comments on registryA specialization is defined by a path of types, from top to bottom in the value graph and target value, which is the value to use when we need a value on 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 AppregistrySpecification of values which become available for construction when a corresponding type comes in contextregistry(The values types that a value depends on!registry"The values that a value depends on$registryThe 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 list'registryList of values available which can be used as parameters to constructors for building other values*registryThis is a list of functions (or "constructors") available for constructing values,registryA Typed value or function can be added to a Registry It is either a value, having both  and * information or a function having just  information/registryDescription of a 3! with input types and output type3registryA Function is the 7 representation of a Haskell function + its description5registryDescription of a value. It might just have a description for its type when it is a value created by the resolution algorithm9registryA 9 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 description@registryMake a ProvidedValueAregistry,make a CreatedValue in no particular contextBregistry3Create a Value from a Haskell value, with only its  descriptionCregistryCreate a Value from a  value and some descriptionDregistryType representation of a 9EregistryDynamic representation of a 9FregistryThe description for a 9GregistryThe dependencies for a 9HregistryA ValueDescription as . If the actual content of the 97 is provided display the type first then the contentKregistry8Return the specialization used when specializing a valueLregistryReturn True if a type is part of the specialization context of a ValueMregistryReturn True if a value has transitives dependencies which are specialized valuesNregistry Create a 3 value from a Haskell functionOregistry Describe a 3 (which doesn't have a - instance) that can be put in the RegistryPregistryShow a Function as  using its DescriptionQregistryThe Description of a 3RregistryDynamic representation of a 3SregistryType representation of a 3TregistryA / as UregistryReturn True if a 3 has some input parametersVregistryDisplay a list of constructorsWregistry.Add one more Function to the list of FunctionsXregistryDisplay a list of valuesYregistry(Add one more Value to the list of ValuesZregistry+Return the target types for a given context[registry(Return the types of all the dependencies\registry.The dependencies of a value + the value itself]registryReturn the various specialization paths which have possibly led to the creation of that value^registryFirst type of a specialization_registryLast type of a specialization`registry9Return the type of the replaced value in a specializationaregistryA specialization is applicable to a context if all its types are part of that context, in the right orderbregistryReturn the specializations valid in a given context Those are the specializations which path is a subpath of the current contextcregistryThe 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 eachdregistryIn 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 SpecializationeregistryDisplay a list of specializations for the Registry, just showing the context (a type) in which a value must be selectedfregistry 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 valuegregistryDisplay a list of modifiers for the Registry, just showing the type of the modified valuemregistryA 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.  !#"$&%')(*+,.-/2103458769;:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg9;:5876<=>?@ABCDEFGHIJKLM34N/210OPQRSTU,.-*+VW')(XY$&%Z!#" [\]^_`abcde fg Safe-Inferred  ")<.8 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 type Safe-Inferred  ")<1 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  ")<4registryApply 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< Double -> Tag Variable Salaryregistry7Apply a function to the last return value of a functionregistryInstance for n argumentsregistryInstance for zero arguments  Safe-Inferred ")1<Wregistry=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<jA&registryThis typeclass take an existing registry and memoize values created for the ls typesregistry-Registry where all output values are memoizedregistryTypeclass 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 typesregistry _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  ")<} !!""#$%%&'())*+,,-../00122344566789::;<==>>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                     registry-0.3.3.3-inplace!Data.Registry.Internal.ReflectionData.Registry.Internal.Types!Data.Registry.Internal.StatisticsData.Registry.Internal.StackData.Registry.Internal.DynamicData.Registry.Internal.RegistryData.Registry.Internal.MakeData.Registry.Internal.DotData.Registry.Internal.CacheData.Registry.LiftData.Registry.SolverData.Registry.RegistryData.Registry.MakeData.Registry.RIOData.Registry.StateData.Registry.StatisticsData.Registry.DotData.Registry.TH Data.RegistryPaths_registry isFunctionshowFullValueTypeshowFullFunctionTypeshowTheFullValueTypeshowTheFullFunctionType showNestedshowSingleTypemustShowModuleName tweakNestedparenthesizeNestedshowWithModuleNameModifierFunction ModifiersSpecializationRange _startRange _endRangeSpecializationContext scContextscSpecializationSpecializationPathSpecialization_specializationPath_specializationValueSpecializationsunSpecializationsDependenciesTypesunDependenciesTypes DependenciesunDependenciesContext _contextStackValuesunValues FunctionsTyped TypedValue TypedFunctionFunctionDescription _inputTypes _outputTypeFunctionValueDescription _valueType _valueValueValue CreatedValue ProvidedValue describeValuedescribeTypeableValue showValue createValuemakeProvidedValuemakeCreatedValuecreateTypeableValuecreateDynValuevalueDynTypeRepvalueDynvalDescriptionvalueDependenciesvalDescriptionToTextvalueSpecializationContext valueContextvalueSpecializationisInSpecializationContexthasSpecializedDependenciescreateFunctiondescribeFunction showFunctionfunDescriptionfunDyn funDynTypeRepfunDescriptionToText hasParametersdescribeFunctions addFunctiondescribeValuesaddValue contextTypesdependenciesTypesdependenciesOnspecializationPathsspecializationStartspecializationEndspecializationTargetTypeisContextApplicable applicableTospecializationRangecreateValueFromSpecializationdescribeSpecializationscreateConstModifierFunctiondescribeModifiers$fHashableValueDescription$fMonoidContext$fSemigroupContext$fHashableValue $fEqValue$fOrdSpecializationRange$fShowModifiers$fSemigroupModifiers$fMonoidModifiers$fEqSpecializationRange$fShowSpecializationRange $fShowValues$fSemigroupValues$fMonoidValues$fShowSpecializations$fSemigroupSpecializations$fMonoidSpecializations$fEqSpecializationContext$fShowSpecializationContext$fEqSpecialization$fShowSpecialization $fShowValue$fEqDependencies$fShowDependencies$fSemigroupDependencies$fMonoidDependencies$fEqDependenciesTypes$fShowDependenciesTypes$fSemigroupDependenciesTypes$fMonoidDependenciesTypes $fEqContext $fShowContext$fShowFunctions$fSemigroupFunctions$fMonoidFunctions$fShowFunction$fEqFunctionDescription$fShowFunctionDescription$fEqValueDescription$fShowValueDescriptionAppliedFunction _outputValue _inputValuesPaths Operations Statistics operationsvaluesinitStatisticsvaluesSpecializationsallValuesPaths valuePathsfindMostRecentValue$fMonoidStatistics$fSemigroupStatistics$fShowStatistics$fShowAppliedFunctionStackrunStackrunStackWithValues execStackexecStackWithValues evalStackevalStackWithValues getValues getOperations modifyValuesmodifyOperationsmodifyStatisticsfunctionApplied applyFunctionapplyModificationapplyFunctionDyn applyOneParamcollectInputTypes outputType findValuefindBestSpecializedValuefindCompatibleCreatedValuefindConstructor storeValue makeUntypedshowContextTargets makeInputs ValueCounterEdgesEdge ValueHashesValueIdHash ValuesByTypeDotStateDotunDot makeEdgestoDotcountValueTypes toDotEdge toDotVertexhashOfnodeDescriptionshowValueCounteradjust removeQuotesescapeNewlines$fEqDot $fShowDotKeyCachefetchnewCache $fEqCacheApplyCNumArgsgetNA 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$fIsSameSettypes1types2MemoizedActionsmemoizeActionsMemoizeRegistry_unMemoizeRegistryPathToTypeReps someTypeReps ERASED_TYPESAddRegistryUncheckedLike<+AddRegistryLike<:Registry_values _functions_specializations _modifiers<+>registerregisterUncheckedappendUncheckedaddTypedUnchecked+: normalize eraseTypes safeCoerce unsafeCoerceendvalvalToliftProvidedValuefunfunTofunAs specializespecializePath specializeValspecializePathValspecializeValTospecializePathValTotweakmemoize memoizeAllstartMemoizeRegistrymakeMemoizeRegistry$fMonoidRegistry$fSemigroupRegistry$fShowRegistry#$fAddRegistryLikeTypedTypedRegistry&$fAddRegistryLikeRegistryTypedRegistry&$fAddRegistryLikeTypedRegistryRegistry)$fAddRegistryLikeRegistryRegistryRegistry,$fAddRegistryUncheckedLikeTypedTypedRegistry/$fAddRegistryUncheckedLikeRegistryTypedRegistry/$fAddRegistryUncheckedLikeTypedRegistryRegistry2$fAddRegistryUncheckedLikeRegistryRegistryRegistry$fPathToTypeReps:$fPathToTypeReps:0$fMemoizedActions:$fMemoizedActions:0$fMemoizedActions[]makemakeSafe makeEithermakeSpecializedmakeSpecializedPathmakeSpecializedEithermakeSpecializedPathEithermakeEitherWithContextRIO withRegistry runRegistryTrunSaddFunToaddFunToUnsafeaddFunS addFunUnsafeSaddToS addToUnsafeSaddFun addFunUnsafe addToRegistry concatUnsafeSaddToRegistryUnsafeconcatRegistryUnsafemakeStatisticsmakeStatisticsEithermakeDot makeDotEitherTypeclassOptions makeTypeclassmakeTypeclassWithbaseGHC.ShowShowData.Typeable.InternalTypeable Data.DynamicDynamic text-1.2.5.0Data.Text.InternalTextGHC.MVarMVarGHC.Base Applicativeghc-prim GHC.TypesIOcreateReadertInstancemakeFunctionDeclarationmakeFunctionInstancecountNumberOfParameters modifyName dropQualifiedversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDir