Data.Registry.Registry

A registry supports the creation of values out of existing values and functions.

It contains 4 parts:

• values: they are available for building anything else and have their exact value can be shown
• functions: they are used to build other values. Only their type can be shown
• specializations: description of specific values to use while trying to build another value of a given type
• modifiers: function to apply to a newly built value before storing it for future use

The <: operator, to append functions or values to a registry:

registry =
     val (Config 1)
  <: val "hello"
  <: fun add1
  <: fun show1

At the type level a list of all the function inputs and all the outputs is being kept to check that when we add a function, all the inputs of that function can be built by the registry. This also ensures that we cannot introduce cycles by adding function which would require each other to build their output

It is possible to use the <+> operator to "override" some configurations:

 mocks =
      fun noLogging
   <: fun inMemoryDb

 mocks <+> registry

Documentation

data Registry (inputs :: [Type]) (outputs :: [Type])

Container for a list of functions or values Internally all functions and values are stored as Dynamic values so that we can access their representation

Constructors

Registry

Fields

• _values :: Values
• _functions :: Functions
• _specializations :: Specializations
• _modifiers :: Modifiers

Instances

(Typeable a, IsSubset (Inputs a) '[Output b] a, Inputs b ~ ('[] :: [Type]), Typeable b, insr ~ (Inputs a :++ (Inputs b :++ ('[] :: [Type]))), 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

Show (Registry inputs outputs)

Defined in Data.Registry.Registry

Methods

showsPrec :: Int -> Registry inputs outputs -> ShowS

show :: Registry inputs outputs -> String

showList :: [Registry inputs outputs] -> ShowS

Semigroup (Registry inputs outputs)

Defined in Data.Registry.Registry

Methods

(<>) :: Registry inputs outputs -> Registry inputs outputs -> Registry inputs outputs

sconcat :: NonEmpty (Registry inputs outputs) -> Registry inputs outputs

stimes :: Integral b => b -> Registry inputs outputs -> Registry inputs outputs

Semigroup (Registry inputs outputs) => Monoid (Registry inputs outputs)

Defined in Data.Registry.Registry

Methods

mempty :: Registry inputs outputs

mappend :: Registry inputs outputs -> Registry inputs outputs -> Registry inputs outputs

mconcat :: [Registry inputs outputs] -> Registry inputs outputs

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

Defined in Data.Registry.Registry

Methods

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

(insr ~ (ins1 :++ ins2), outr ~ (out1 :++ out2)) => AddRegistryLike (Registry ins1 out1) (Registry ins2 out2) (Registry insr outr)

Defined in Data.Registry.Registry

Methods

(<:) :: Registry ins1 out1 -> Registry ins2 out2 -> Registry insr outr

(<+>) :: Registry is1 os1 -> Registry is2 os2 -> Registry (is1 :++ is2) (os1 :++ os2) infixr 4

Append 2 registries together

register :: (Typeable a, IsSubset (Inputs a) out a) => Typed a -> Registry ins out -> Registry (Inputs a :++ ins) (Output a ': out)

Store an element in the registry Internally elements are stored as Dynamic values The signature checks that a constructor of type a can be fully constructed from elements of the registry before adding it

registerUnchecked :: Typeable a => Typed a -> Registry ins out -> Registry (Inputs a :++ ins) (Output a ': out)

Store an element in the registry Internally elements are stored as Dynamic values

(+:) :: Typeable a => Typed a -> Registry ins out -> Registry (Inputs a :++ ins) (Output a ': out) infixr 5

Add an element to the Registry but do not check that the inputs of a can already be produced by the registry

class AddRegistryLike a b c | a b -> c where

Methods

(<:) :: a -> b -> c infixr 5

Instances

(Typeable a, IsSubset (Inputs a) '[Output b] a, Inputs b ~ ('[] :: [Type]), Typeable b, insr ~ (Inputs a :++ (Inputs b :++ ('[] :: [Type]))), 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, IsSubset (Inputs a) out2 a, insr ~ (Inputs a :++ ins2), outr ~ (Output a ': out2)) => AddRegistryLike (Registry ins2 out2) (Typed a) (Registry insr outr)

Defined in Data.Registry.Registry

Methods

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

(insr ~ (ins1 :++ ins2), outr ~ (out1 :++ out2)) => AddRegistryLike (Registry ins1 out1) (Registry ins2 out2) (Registry insr outr)

Defined in Data.Registry.Registry

Methods

(<:) :: Registry ins1 out1 -> Registry ins2 out2 -> Registry insr outr

normalize :: Registry ins out -> Registry (Normalized ins) (Normalized out)

Make the lists of types in the Registry unique, either for better display or for faster compile-time resolution with the make function

eraseTypes :: Registry ins out -> Registry '[ERASED_TYPES] '[ERASED_TYPES]

Remove 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 it

data ERASED_TYPES

safeCoerce :: IsSameSet out out1 => Registry ins out -> Registry ins1 out1

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

unsafeCoerce :: Registry ins out -> Registry ins1 out1

And for extreme cases where you know you're doing the right thing but can't prove it

end :: Registry '[] '[]

The empty Registry

val :: (Typeable a, Show a) => a -> Typed a

Create a value which can be added to the Registry

valTo :: forall m a. (Applicative m, Typeable a, Typeable (m a), Show a) => a -> Typed (m a)

Create a value which can be added to the Registry and "lift" it to an Applicative context

liftProvidedValue :: forall m a. (Applicative m, Typeable a, Typeable (m a), Show a) => a -> Value

Create a "lifted" a Value

fun :: Typeable a => a -> Typed a

Create a function which can be added to the Registry

funTo :: forall m a b. (ApplyVariadic m a b, Typeable a, Typeable b) => a -> Typed b

This is a shortcut to fun . allTo where allTo lifts all the inputs and output to an Applicative context

funAs :: forall m a b. (ApplyVariadic1 m a b, Typeable a, Typeable b) => a -> Typed b

This is a shortcut to fun . argsTo where allTo lifts the inputs only to an Applicative context In general funTo should work, even with function already returning an m a but if this is not the case (see issue #7) then funAs can be used

specialize :: forall a b ins out. (Typeable a, Typeable b) => b -> Registry ins out -> Registry ins out

For a given type a being currently built when a value of type b is required pass a specific value

specializePath :: forall path b ins out. (PathToTypeReps path, Typeable b) => b -> Registry ins out -> Registry ins out

specializeVal :: forall a b ins out. (Typeable a, Contains a out, Typeable b, Show b) => b -> Registry ins out -> Registry ins out

specializePathVal :: forall path b ins out. (PathToTypeReps path, Typeable b, Show b) => b -> Registry ins out -> Registry ins out

specializeValTo :: forall m a b ins out. (Applicative m, Typeable a, Typeable (m b), Typeable b, Show b) => b -> Registry ins out -> Registry ins out

specializePathValTo :: forall m path b ins out. (Applicative m, PathToTypeReps path, Typeable (m b), Typeable b, Show b) => b -> Registry ins out -> Registry ins out

class PathToTypeReps (path :: [Type]) where

Typeclass for extracting type representations out of a list of types

Methods

someTypeReps :: Proxy path -> NonEmpty SomeTypeRep

Instances

(Typeable a, PathToTypeReps rest) => PathToTypeReps (a ': rest)

Defined in Data.Registry.Registry

Methods

someTypeReps :: Proxy (a ': rest) -> NonEmpty SomeTypeRep

Typeable a => PathToTypeReps '[a]

Defined in Data.Registry.Registry

Methods

someTypeReps :: Proxy '[a] -> NonEmpty SomeTypeRep

tweak :: forall a ins out. Typeable a => (a -> a) -> Registry ins out -> Registry ins out

Once a value has been computed allow to modify it before storing it This keeps the same registry type

Memoization

memoize :: forall m a ins out. (MonadIO m, Typeable a, Typeable (m a)) => Registry ins out -> IO (Registry ins out)

Instantiating components can trigger side-effects The way the resolution algorithm works a component of type `m a` will be re-executed *everytime* it is needed as a given dependency This section adds support for memoizing those actions (component creation + optional warmup)

Return memoized values for a monadic type Note that the returned Registry is in IO because we are caching a value and this is a side-effect!

memoizeAll :: forall m ins out. (MonadIO m, MemoizedActions out) => Registry ins out -> IO (Registry ins out)

Memoize *all* the output actions of a Registry when they are creating effectful components This relies on a helper data structure MemoizeRegistry tracking the types already memoized and a typeclass MemoizedActions going through the list of out types to process them one by one. Note that a type of the form a will not be memoized (only `m a`)

newtype MemoizeRegistry (todo :: [Type]) (ins :: [Type]) (out :: [Type])

Constructors

MemoizeRegistry

Fields

• _unMemoizeRegistry :: Registry ins out

startMemoizeRegistry :: Registry ins out -> MemoizeRegistry out ins out

makeMemoizeRegistry :: forall todo ins out. Registry ins out -> MemoizeRegistry todo ins out

class MemoizedActions ls where

Methods

memoizeActions :: MemoizeRegistry ls ins out -> IO (MemoizeRegistry '[] ins out)

Instances

MemoizedActions ('[] :: [Type])

Defined in Data.Registry.Registry

Methods

memoizeActions :: forall (ins :: [Type]) (out :: [Type]). MemoizeRegistry '[] ins out -> IO (MemoizeRegistry '[] ins out)

MemoizedActions rest => MemoizedActions (a ': rest)

Defined in Data.Registry.Registry

Methods

memoizeActions :: forall (ins :: [Type]) (out :: [Type]). MemoizeRegistry (a ': rest) ins out -> IO (MemoizeRegistry '[] ins out)

(MonadIO m, Typeable a, Typeable (m a), MemoizedActions rest) => MemoizedActions (m a ': rest)

Defined in Data.Registry.Registry

Methods

memoizeActions :: forall (ins :: [Type]) (out :: [Type]). MemoizeRegistry (m a ': rest) ins out -> IO (MemoizeRegistry '[] ins out)