Data.Registry.Internal.Types

List of types used inside the Registry

Documentation

data Value

A Value is the Dynamic 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 application

Dependencies is the transitive list of all the values used to create a CreatedValue

The 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)

Constructors

CreatedValue Dynamic ValueDescription (Maybe SpecializationContext) Dependencies

ProvidedValue Dynamic ValueDescription

Instances

Show Value

Defined in Data.Registry.Internal.Types

Methods

showsPrec :: Int -> Value -> ShowS

show :: Value -> String

showList :: [Value] -> ShowS

Eq Value

Defined in Data.Registry.Internal.Types

Methods

(==) :: Value -> Value -> Bool

(/=) :: Value -> Value -> Bool

Hashable Value

Defined in Data.Registry.Internal.Types

Methods

hashWithSalt :: Int -> Value -> Int

hash :: Value -> Int

data ValueDescription

Description of a value. It might just have a description for its type when it is a value created by the resolution algorithm

Constructors

ValueDescription

Fields

• _valueType :: Text
• _valueValue :: Maybe Text

Instances

Show ValueDescription

Defined in Data.Registry.Internal.Types

Methods

showsPrec :: Int -> ValueDescription -> ShowS

show :: ValueDescription -> String

showList :: [ValueDescription] -> ShowS

Eq ValueDescription

Defined in Data.Registry.Internal.Types

Methods

(==) :: ValueDescription -> ValueDescription -> Bool

(/=) :: ValueDescription -> ValueDescription -> Bool

Hashable ValueDescription

Defined in Data.Registry.Internal.Types

Methods

hashWithSalt :: Int -> ValueDescription -> Int

hash :: ValueDescription -> Int

describeValue :: (Typeable a, Show a) => a -> ValueDescription

Describe a value with its type and actual content

describeTypeableValue :: Typeable a => a -> ValueDescription

Describe a value with only its type

showValue :: Value -> Text

Show a Value from the Registry

createValue :: (Typeable a, Show a) => a -> Value

Create a Value from a Haskell value, using its Show instance for its description

makeProvidedValue :: Dynamic -> ValueDescription -> Value

Make a ProvidedValue

makeCreatedValue :: Dynamic -> ValueDescription -> Dependencies -> Value

make a CreatedValue in no particular context

createTypeableValue :: Typeable a => a -> Value

Create a Value from a Haskell value, with only its Typeable description

createDynValue :: Dynamic -> Text -> Value

Create a Value from a Dynamic value and some description

valueDynTypeRep :: Value -> SomeTypeRep

Type representation of a Value

valueDyn :: Value -> Dynamic

Dynamic representation of a Value

valDescription :: Value -> ValueDescription

The description for a Value

valueDependencies :: Value -> Dependencies

The dependencies for a Value

valDescriptionToText :: ValueDescription -> Text

A ValueDescription as Text. If the actual content of the Value is provided display the type first then the content

valueSpecializationContext :: Value -> Maybe SpecializationContext

valueContext :: Value -> Maybe Context

valueSpecialization :: Value -> Maybe Specialization

Return the specialization used when specializing a value

isInSpecializationContext :: SomeTypeRep -> Value -> Bool

Return True if a type is part of the specialization context of a Value

hasSpecializedDependencies :: Specializations -> Value -> Bool

Return True if a value has transitives dependencies which are specialized values

data Function

A Function is the Dynamic representation of a Haskell function + its description

Constructors

Function Dynamic FunctionDescription

Instances

Show Function

Defined in Data.Registry.Internal.Types

Methods

showsPrec :: Int -> Function -> ShowS

show :: Function -> String

showList :: [Function] -> ShowS

createFunction :: Typeable f => f -> Function

Create a Function value from a Haskell function

data FunctionDescription

Description of a Function with input types and output type

Constructors

FunctionDescription

Fields

• _inputTypes :: [Text]
• _outputType :: Text

Instances

Show FunctionDescription

Defined in Data.Registry.Internal.Types

Methods

showsPrec :: Int -> FunctionDescription -> ShowS

show :: FunctionDescription -> String

showList :: [FunctionDescription] -> ShowS

Eq FunctionDescription

Defined in Data.Registry.Internal.Types

Methods

(==) :: FunctionDescription -> FunctionDescription -> Bool

(/=) :: FunctionDescription -> FunctionDescription -> Bool

describeFunction :: Typeable a => a -> FunctionDescription

Describe a Function (which doesn't have a Show instance) that can be put in the Registry

showFunction :: Function -> Text

Show a Function as Text using its Description

funDescription :: Function -> FunctionDescription

The Description of a Function

funDyn :: Function -> Dynamic

Dynamic representation of a Function

funDynTypeRep :: Function -> SomeTypeRep

Type representation of a Function

funDynOutTypeRep :: Function -> SomeTypeRep

Type representation of the output of a Function

funDescriptionToText :: FunctionDescription -> Text

A FunctionDescription as Text

hasParameters :: Function -> Bool

Return True if a Function has some input parameters

data Typed a

A Typed value or function can be added to a Registry It is either a value, having both Show and Typeable information or a function having just Typeable information

Constructors

TypedValue Value

TypedFunction Function

Instances

(Typeable a, IsSubset (Inputs a) '[Output b] a, Typeable b, insr ~ (Inputs a :++ Inputs b), outr ~ '[Output a, Output b]) => AddRegistryLike (Typed a) (Typed b) (Registry insr outr)

Defined in Data.Registry.Registry

Methods

(<:) :: Typed a -> Typed b -> Registry insr outr

(Typeable a, IsSubset (Inputs a) out2 a, insr ~ (Inputs a :++ ins2), outr ~ (Output a ': out2)) => AddRegistryLike (Typed a) (Registry ins2 out2) (Registry insr outr)

Defined in Data.Registry.Registry

Methods

(<:) :: Typed a -> Registry ins2 out2 -> Registry insr outr

(Typeable a, AreSubset ins2 outr out2, insr ~ (ins2 :++ Inputs a), outr ~ (out2 :++ '[Output a])) => AddRegistryLike (Registry ins2 out2) (Typed a) (Registry insr outr)

Defined in Data.Registry.Registry

Methods

(<:) :: Registry ins2 out2 -> Typed a -> Registry insr outr

(Typeable a, Typeable b, insr ~ (Inputs a :++ Inputs b), outr ~ '[Output a, Output b]) => AddRegistryUncheckedLike (Typed a) (Typed b) (Registry insr outr)

Defined in Data.Registry.Registry

Methods

(<+) :: Typed a -> Typed b -> Registry insr outr

(Typeable a, insr ~ (Inputs a :++ ins2), outr ~ (Output a ': out2)) => AddRegistryUncheckedLike (Typed a) (Registry ins2 out2) (Registry insr outr)

Defined in Data.Registry.Registry

Methods

(<+) :: Typed a -> Registry ins2 out2 -> Registry insr outr

(Typeable a, insr ~ (ins2 :++ Inputs a), outr ~ (out2 :++ '[Output a])) => AddRegistryUncheckedLike (Registry ins2 out2) (Typed a) (Registry insr outr)

Defined in Data.Registry.Registry

Methods

(<+) :: Registry ins2 out2 -> Typed a -> Registry insr outr

data Untyped

A Untyped is used for storing either a value or a function in a specialization

Constructors

UntypedValue Value

UntypedFunction Function

Instances

Show Untyped

Defined in Data.Registry.Internal.Types

Methods

showsPrec :: Int -> Untyped -> ShowS

show :: Untyped -> String

showList :: [Untyped] -> ShowS

untype :: Typed a -> Untyped

Drop the type variable

newtype Functions

This is a list of functions (or "constructors") available for constructing values They are sorted by output type and if there are several available functions for a given type the first function in the list has the highest priority

Constructors

Functions

Fields

• unFunctions :: MultiMap SomeTypeRep Function

Instances

Monoid Functions

Defined in Data.Registry.Internal.Types

Methods

mempty :: Functions

mappend :: Functions -> Functions -> Functions

mconcat :: [Functions] -> Functions

Semigroup Functions

Defined in Data.Registry.Internal.Types

Methods

(<>) :: Functions -> Functions -> Functions

sconcat :: NonEmpty Functions -> Functions

stimes :: Integral b => b -> Functions -> Functions

Show Functions

Defined in Data.Registry.Internal.Types

Methods

showsPrec :: Int -> Functions -> ShowS

show :: Functions -> String

showList :: [Functions] -> ShowS

fromFunctions :: [Function] -> Functions

Create a Functions data structure from a list of functions

toFunctions :: Functions -> [Function]

Create a list of functions from the Functions data structure

describeFunctions :: Functions -> Text

Display a list of constructors

addFunction :: Function -> Functions -> Functions

Add one more Function to the list of Functions. It gets the highest priority for functions with the same output type

appendFunction :: Function -> Functions -> Functions

Add one more Function to the list of Functions 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 map

findFunction :: SomeTypeRep -> Functions -> Maybe Function

Find a constructor function returning a target type from a list of constructors

newtype Values

List of values available which can be used as parameters to constructors for building other values

Constructors

Values

Fields

• unValues :: MultiMap SomeTypeRep Value

Instances

Monoid Values

Defined in Data.Registry.Internal.Types

Methods

mempty :: Values

mappend :: Values -> Values -> Values

mconcat :: [Values] -> Values

Semigroup Values

Defined in Data.Registry.Internal.Types

Methods

(<>) :: Values -> Values -> Values

sconcat :: NonEmpty Values -> Values

stimes :: Integral b => b -> Values -> Values

Show Values

Defined in Data.Registry.Internal.Types

Methods

showsPrec :: Int -> Values -> ShowS

show :: Values -> String

showList :: [Values] -> ShowS

fromValues :: [Value] -> Values

Create a Values data structure from a list of values

toValues :: Values -> [Value]

Create a list of values from the Values data structure

describeValues :: Values -> Text

Display a list of values

addValue :: Value -> Values -> Values

Add one more Value to the list of Values

appendValue :: Value -> Values -> Values

Add 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 map

findValues :: SomeTypeRep -> Values -> [Value]

Find all the values with a specific type from a list of constructors

newtype Context

The 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

Constructors

Context

Fields

• _contextStack :: [(SomeTypeRep, Maybe SomeTypeRep)]

Instances

Monoid Context

Defined in Data.Registry.Internal.Types

Methods

mempty :: Context

mappend :: Context -> Context -> Context

mconcat :: [Context] -> Context

Semigroup Context

Defined in Data.Registry.Internal.Types

Methods

(<>) :: Context -> Context -> Context

sconcat :: NonEmpty Context -> Context

stimes :: Integral b => b -> Context -> Context

Show Context

Defined in Data.Registry.Internal.Types

Methods

showsPrec :: Int -> Context -> ShowS

show :: Context -> String

showList :: [Context] -> ShowS

Eq Context

Defined in Data.Registry.Internal.Types

Methods

(==) :: Context -> Context -> Bool

(/=) :: Context -> Context -> Bool

contextTypes :: Context -> [SomeTypeRep]

Return the target types for a given context

newtype Dependencies

The values that a value depends on

Constructors

Dependencies

Fields

• unDependencies :: [Value]

Instances

Monoid Dependencies

Defined in Data.Registry.Internal.Types

Methods

mempty :: Dependencies

mappend :: Dependencies -> Dependencies -> Dependencies

mconcat :: [Dependencies] -> Dependencies

Semigroup Dependencies

Defined in Data.Registry.Internal.Types

Methods

(<>) :: Dependencies -> Dependencies -> Dependencies

sconcat :: NonEmpty Dependencies -> Dependencies

stimes :: Integral b => b -> Dependencies -> Dependencies

Show Dependencies

Defined in Data.Registry.Internal.Types

Methods

showsPrec :: Int -> Dependencies -> ShowS

show :: Dependencies -> String

showList :: [Dependencies] -> ShowS

Eq Dependencies

Defined in Data.Registry.Internal.Types

Methods

(==) :: Dependencies -> Dependencies -> Bool

(/=) :: Dependencies -> Dependencies -> Bool

newtype DependenciesTypes

The values types that a value depends on

Constructors

DependenciesTypes

Fields

• unDependenciesTypes :: [SomeTypeRep]

Instances

Monoid DependenciesTypes

Defined in Data.Registry.Internal.Types

Methods

mempty :: DependenciesTypes

mappend :: DependenciesTypes -> DependenciesTypes -> DependenciesTypes

mconcat :: [DependenciesTypes] -> DependenciesTypes

Semigroup DependenciesTypes

Defined in Data.Registry.Internal.Types

Methods

(<>) :: DependenciesTypes -> DependenciesTypes -> DependenciesTypes

sconcat :: NonEmpty DependenciesTypes -> DependenciesTypes

stimes :: Integral b => b -> DependenciesTypes -> DependenciesTypes

Show DependenciesTypes

Defined in Data.Registry.Internal.Types

Methods

showsPrec :: Int -> DependenciesTypes -> ShowS

show :: DependenciesTypes -> String

showList :: [DependenciesTypes] -> ShowS

Eq DependenciesTypes

Defined in Data.Registry.Internal.Types

Methods

(==) :: DependenciesTypes -> DependenciesTypes -> Bool

(/=) :: DependenciesTypes -> DependenciesTypes -> Bool

dependenciesTypes :: Dependencies -> DependenciesTypes

Return the types of all the dependencies

dependenciesOn :: Value -> Dependencies

The dependencies of a value + the value itself

newtype Specializations

Specification of values which become available for construction when a corresponding type comes in context

Constructors

Specializations

Fields

• unSpecializations :: [Specialization]

Instances

Monoid Specializations

Defined in Data.Registry.Internal.Types

Methods

mempty :: Specializations

mappend :: Specializations -> Specializations -> Specializations

mconcat :: [Specializations] -> Specializations

Semigroup Specializations

Defined in Data.Registry.Internal.Types

Methods

(<>) :: Specializations -> Specializations -> Specializations

sconcat :: NonEmpty Specializations -> Specializations

stimes :: Integral b => b -> Specializations -> Specializations

Show Specializations

Defined in Data.Registry.Internal.Types

Methods

showsPrec :: Int -> Specializations -> ShowS

show :: Specializations -> String

showList :: [Specializations] -> ShowS

data Specialization

A 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 App

Constructors

Specialization

Fields

• _specializationPath :: SpecializationPath
• _specializationValue :: Untyped

Instances

Show Specialization

Defined in Data.Registry.Internal.Types

Methods

showsPrec :: Int -> Specialization -> ShowS

show :: Specialization -> String

showList :: [Specialization] -> ShowS

type SpecializationPath = NonEmpty SomeTypeRep

List of consecutive types used when making a specific values See the comments on Specialization

specializationPaths :: Value -> Maybe [SpecializationPath]

Return the various specialization paths which have possibly led to the creation of that value

specializationStart :: Specialization -> SomeTypeRep

First type of a specialization

specializationEnd :: Specialization -> SomeTypeRep

Last type of a specialization

specializationTargetType :: Specialization -> SomeTypeRep

Return the type of the replaced value in a specialization

data SpecializationContext

This 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 case

Constructors

SpecializationContext

Fields

• scContext :: Context
• scSpecialization :: Specialization

Instances

Show SpecializationContext

Defined in Data.Registry.Internal.Types

Methods

showsPrec :: Int -> SpecializationContext -> ShowS

show :: SpecializationContext -> String

showList :: [SpecializationContext] -> ShowS

isContextApplicable :: Context -> Specialization -> Bool

A specialization is applicable to a context if all its types are part of that context, in the right order

applicableTo :: Specializations -> Context -> Specializations

Return the specializations valid in a given context Those are the specializations which path is a subpath of the current context

specializationRange :: Context -> Specialization -> SpecializationRange

The 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 each

data SpecializationRange

For 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.

Constructors

SpecializationRange

Fields

• _startRange :: Maybe Int
• _endRange :: Maybe Int

Instances

Show SpecializationRange

Defined in Data.Registry.Internal.Types

Methods

showsPrec :: Int -> SpecializationRange -> ShowS

show :: SpecializationRange -> String

showList :: [SpecializationRange] -> ShowS

Eq SpecializationRange

Defined in Data.Registry.Internal.Types

Methods

(==) :: SpecializationRange -> SpecializationRange -> Bool

(/=) :: SpecializationRange -> SpecializationRange -> Bool

Ord SpecializationRange

A 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.

Defined in Data.Registry.Internal.Types

Methods

compare :: SpecializationRange -> SpecializationRange -> Ordering

(<) :: SpecializationRange -> SpecializationRange -> Bool

(<=) :: SpecializationRange -> SpecializationRange -> Bool

(>) :: SpecializationRange -> SpecializationRange -> Bool

(>=) :: SpecializationRange -> SpecializationRange -> Bool

max :: SpecializationRange -> SpecializationRange -> SpecializationRange

min :: SpecializationRange -> SpecializationRange -> SpecializationRange

createValueFromSpecialization :: Context -> Specialization -> Untyped

In 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 Specialization

describeSpecializations :: Specializations -> Text

Display a list of specializations for the Registry, just showing the context (a type) in which a value must be selected

newtype Modifiers

List 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

Constructors

Modifiers [(SomeTypeRep, ModifierFunction)]

Instances

Monoid Modifiers

Defined in Data.Registry.Internal.Types

Methods

mempty :: Modifiers

mappend :: Modifiers -> Modifiers -> Modifiers

mconcat :: [Modifiers] -> Modifiers

Semigroup Modifiers

Defined in Data.Registry.Internal.Types

Methods

(<>) :: Modifiers -> Modifiers -> Modifiers

sconcat :: NonEmpty Modifiers -> Modifiers

stimes :: Integral b => b -> Modifiers -> Modifiers

Show Modifiers

Defined in Data.Registry.Internal.Types

Methods

showsPrec :: Int -> Modifiers -> ShowS

show :: Modifiers -> String

showList :: [Modifiers] -> ShowS

type ModifierFunction = Maybe [SpecializationPath] -> Function

A 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.

createConstModifierFunction :: Typeable f => f -> ModifierFunction

Create a ModifierFunction 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 value

describeModifiers :: Modifiers -> Text

Display a list of modifiers for the Registry, just showing the type of the modified value