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

A registry is created by using the +: operator, adding functions or values to the empty end registry:

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

At the type level a list of all the function inputs and all the outputs is being kept to allow some checks to be made when we want to build a value out of the registry.

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

 mocks =
      fun noLogging
   +: fun inMemoryDb
   +: end

 mocks <+> registry

Documentation

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

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, Typeable b, insr ~ (Inputs a :++ (Inputs b :++ ([] :: [Type]))), outr ~ (Output a ': (Output b ': ([] :: [Type])))) => AddRegistryLike (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)) => 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, 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 => 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 - Alternative to register where the parentheses can be ommitted

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

Methods

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

Instances

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

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

specialize :: forall a b ins out. (Typeable a, Contains a out, 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, IsSubset path out, 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

This is similar to specialize but additionally uses the Show instance of b to display more information when printing the registry out

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

specializeValTo :: forall m a b ins out. (Applicative m, Typeable a, Contains a out, 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, IsSubset path out, Typeable (m b), Typeable b, Show b) => b -> Registry ins out -> Registry ins out

specializeUnsafe :: 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

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

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

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

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

specializePathUnsafeValTo :: 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 :: [*]) 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 ': ([] :: [Type]))

Defined in Data.Registry.Registry

Methods

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

tweak :: forall a ins out. (Typeable a, Contains a out) => (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

tweakUnsafe :: 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

Memoization

memoize :: forall m a ins out. (MonadIO m, Typeable a, Typeable (m a), Contains (m a) out) => 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!

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

Memoize an action for a given type but don't check if the value is part of the registry outputs

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 :: [*]) (ins :: [*]) (out :: [*])

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 :: MemoizeRegistry [] ins out -> IO (MemoizeRegistry [] ins out)

MemoizedActions rest => MemoizedActions (a ': rest)

Defined in Data.Registry.Registry

Methods

memoizeActions :: 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 :: MemoizeRegistry (m a ': rest) ins out -> IO (MemoizeRegistry [] ins out)

DEPRECATIONS

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

Deprecated: use memoize instead

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

Deprecated: use memoizeUnsafe instead