{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE MonoLocalBinds #-}
{-# LANGUAGE UndecidableInstances #-}

-- |
--  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
module Data.Registry.Registry where

import Data.Dynamic
import Data.Registry.Internal.Cache
import Data.Registry.Internal.Types
import Data.Registry.Lift
import Data.Registry.Solver
import Data.Semigroup ((<>))
import Protolude as P hiding ((<>))
import Type.Reflection
import qualified Prelude (show)

-- | 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
data Registry (inputs :: [Type]) (outputs :: [Type]) = Registry
  { forall (inputs :: [*]) (outputs :: [*]).
Registry inputs outputs -> Values
_values :: Values,
    forall (inputs :: [*]) (outputs :: [*]).
Registry inputs outputs -> Functions
_functions :: Functions,
    forall (inputs :: [*]) (outputs :: [*]).
Registry inputs outputs -> Specializations
_specializations :: Specializations,
    forall (inputs :: [*]) (outputs :: [*]).
Registry inputs outputs -> Modifiers
_modifiers :: Modifiers
  }

instance Show (Registry inputs outputs) where
  show :: Registry inputs outputs -> String
show (Registry Values
vs Functions
fs ss :: Specializations
ss@(Specializations [Specialization]
ss') ms :: Modifiers
ms@(Modifiers [(SomeTypeRep, ModifierFunction)]
ms')) =
    forall a b. ConvertText a b => a -> b
toS forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Text] -> Text
unlines forall a b. (a -> b) -> a -> b
$
      [ Text
"Values\n",
        Values -> Text
describeValues Values
vs,
        Text
"Constructors\n",
        Functions -> Text
describeFunctions Functions
fs
      ]
        forall a. Semigroup a => a -> a -> a
<> ( if Bool -> Bool
not (forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Specialization]
ss')
               then
                 [ Text
"Specializations\n",
                   Specializations -> Text
describeSpecializations Specializations
ss
                 ]
               else []
           )
        forall a. Semigroup a => a -> a -> a
<> ( if Bool -> Bool
not (forall (t :: * -> *) a. Foldable t => t a -> Bool
null [(SomeTypeRep, ModifierFunction)]
ms')
               then
                 [ Text
"Modifiers\n",
                   Modifiers -> Text
describeModifiers Modifiers
ms
                 ]
               else []
           )

instance Semigroup (Registry inputs outputs) where
  <> :: Registry inputs outputs
-> Registry inputs outputs -> Registry inputs outputs
(<>) (Registry Values
vs1 Functions
fs1 Specializations
ss1 Modifiers
ms1) (Registry Values
vs2 Functions
fs2 Specializations
ss2 Modifiers
ms2) =
      forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry (Values
vs1 forall a. Semigroup a => a -> a -> a
<> Values
vs2) (Functions
fs1 forall a. Semigroup a => a -> a -> a
<> Functions
fs2) (Specializations
ss1 forall a. Semigroup a => a -> a -> a
<> Specializations
ss2) (Modifiers
ms1 forall a. Semigroup a => a -> a -> a
<> Modifiers
ms2)

instance Semigroup (Registry inputs outputs) => Monoid (Registry inputs outputs) where
  mempty :: Registry inputs outputs
mempty = forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry forall a. Monoid a => a
mempty forall a. Monoid a => a
mempty forall a. Monoid a => a
mempty forall a. Monoid a => a
mempty
  mappend :: Registry inputs outputs
-> Registry inputs outputs -> Registry inputs outputs
mappend = forall a. Semigroup a => a -> a -> a
(<>)

-- | Append 2 registries together
infixr 4 <+>

(<+>) :: Registry is1 os1 -> Registry is2 os2 -> Registry (is1 :++ is2) (os1 :++ os2)
<+> :: forall (is1 :: [*]) (os1 :: [*]) (is2 :: [*]) (os2 :: [*]).
Registry is1 os1
-> Registry is2 os2 -> Registry (is1 :++ is2) (os1 :++ os2)
(<+>)(Registry Values
vs1 Functions
fs1 Specializations
ss1 Modifiers
ms1) (Registry Values
vs2 Functions
fs2 Specializations
ss2 Modifiers
ms2) =
      forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry (Values
vs1 forall a. Semigroup a => a -> a -> a
<> Values
vs2) (Functions
fs1 forall a. Semigroup a => a -> a -> a
<> Functions
fs2) (Specializations
ss1 forall a. Semigroup a => a -> a -> a
<> Specializations
ss2) (Modifiers
ms1 forall a. Semigroup a => a -> a -> a
<> Modifiers
ms2)

-- | 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
register :: (Typeable a, IsSubset (Inputs a) out a) => Typed a -> Registry ins out -> Registry (Inputs a :++ ins) (Output a ': out)
register :: forall a (out :: [*]) (ins :: [*]).
(Typeable a, IsSubset (Inputs a) out a) =>
Typed a
-> Registry ins out -> Registry (Inputs a :++ ins) (Output a : out)
register = forall a (ins :: [*]) (out :: [*]).
Typeable a =>
Typed a
-> Registry ins out -> Registry (Inputs a :++ ins) (Output a : out)
registerUnchecked

-- | Store an element in the registry
--   Internally elements are stored as 'Dynamic' values
registerUnchecked :: (Typeable a) => Typed a -> Registry ins out -> Registry (Inputs a :++ ins) (Output a ': out)
registerUnchecked :: forall a (ins :: [*]) (out :: [*]).
Typeable a =>
Typed a
-> Registry ins out -> Registry (Inputs a :++ ins) (Output a : out)
registerUnchecked (TypedValue Value
v) (Registry Values
values Functions
functions Specializations
specializations Modifiers
modifiers) =
  forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry (Value -> Values -> Values
addValue Value
v Values
values) Functions
functions Specializations
specializations Modifiers
modifiers
registerUnchecked (TypedFunction Function
f) (Registry Values
values Functions
functions Specializations
specializations Modifiers
modifiers) =
  forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry Values
values (Function -> Functions -> Functions
addFunction Function
f Functions
functions) Specializations
specializations Modifiers
modifiers

-- | Store an element in the registry, at the end of the registry
--   Internally elements are stored as 'Dynamic' values
appendUnchecked :: (Typeable a) => Registry ins out -> Typed a -> Registry (ins :++ Inputs a) (out :++ '[Output a])
appendUnchecked :: forall a (ins :: [*]) (out :: [*]).
Typeable a =>
Registry ins out
-> Typed a -> Registry (ins :++ Inputs a) (out :++ '[Output a])
appendUnchecked (Registry Values
values Functions
functions Specializations
specializations Modifiers
modifiers) (TypedValue Value
v) =
  forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry (Value -> Values -> Values
appendValue Value
v Values
values) Functions
functions Specializations
specializations Modifiers
modifiers
appendUnchecked (Registry Values
values Functions
functions Specializations
specializations Modifiers
modifiers) (TypedFunction Function
f) =
  forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry Values
values (Function -> Functions -> Functions
appendFunction Function
f Functions
functions) Specializations
specializations Modifiers
modifiers

-- | Add 2 typed values together to form an initial registry
addTypedUnchecked :: (Typeable a, Typeable b, ins ~ (Inputs a :++ Inputs b), out ~ '[Output a, Output b]) => Typed a -> Typed b -> Registry ins out
addTypedUnchecked :: forall a b (ins :: [*]) (out :: [*]).
(Typeable a, Typeable b, ins ~ (Inputs a :++ Inputs b),
 out ~ '[Output a, Output b]) =>
Typed a -> Typed b -> Registry ins out
addTypedUnchecked (TypedValue Value
v1) (TypedValue Value
v2) = forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry ([Value] -> Values
fromValues [Value
v1, Value
v2]) forall a. Monoid a => a
mempty forall a. Monoid a => a
mempty forall a. Monoid a => a
mempty
addTypedUnchecked (TypedValue Value
v1) (TypedFunction Function
f2) = forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry ([Value] -> Values
fromValues [Value
v1]) ([Function] -> Functions
fromFunctions [Function
f2]) forall a. Monoid a => a
mempty forall a. Monoid a => a
mempty
addTypedUnchecked (TypedFunction Function
f1) (TypedValue Value
v2) = forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry ([Value] -> Values
fromValues [Value
v2]) ([Function] -> Functions
fromFunctions [Function
f1]) forall a. Monoid a => a
mempty forall a. Monoid a => a
mempty
addTypedUnchecked (TypedFunction Function
f1) (TypedFunction Function
f2) = forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry forall a. Monoid a => a
mempty ([Function] -> Functions
fromFunctions [Function
f1, Function
f2]) forall a. Monoid a => a
mempty forall a. Monoid a => a
mempty

-- | Add an element to the Registry but do not check that the inputs of a
--   can already be produced by the registry
infixr 5 +:

-- | Prepend an element to the registry with no checks at all
(+:) :: (Typeable a) => Typed a -> Registry ins out -> Registry (Inputs a :++ ins) (Output a ': out)
+: :: forall a (ins :: [*]) (out :: [*]).
Typeable a =>
Typed a
-> Registry ins out -> Registry (Inputs a :++ ins) (Output a : out)
(+:) = forall a (ins :: [*]) (out :: [*]).
Typeable a =>
Typed a
-> Registry ins out -> Registry (Inputs a :++ ins) (Output a : out)
registerUnchecked

-- Unification of +: and <+>
infixr 5 <:

-- | Typeclass for appending values and or registries together, with static checks
class AddRegistryLike a b c | a b -> c where
  (<:) :: a -> b -> c

instance (insr ~ (ins1 :++ ins2), outr ~ (out1 :++ out2), AreSubset ins1 outr out1) => AddRegistryLike (Registry ins1 out1) (Registry ins2 out2) (Registry insr outr) where
  <: :: Registry ins1 out1 -> Registry ins2 out2 -> Registry insr outr
(<:) = forall (is1 :: [*]) (os1 :: [*]) (is2 :: [*]) (os2 :: [*]).
Registry is1 os1
-> Registry is2 os2 -> Registry (is1 :++ is2) (os1 :++ os2)
(<+>)

instance
  (Typeable a, IsSubset (Inputs a) out2 a, insr ~ (Inputs a :++ ins2), outr ~ (Output a : out2)) =>
  AddRegistryLike (Typed a) (Registry ins2 out2) (Registry insr outr)
  where
  <: :: Typed a -> Registry ins2 out2 -> Registry insr outr
(<:) = forall a (out :: [*]) (ins :: [*]).
(Typeable a, IsSubset (Inputs a) out a) =>
Typed a
-> Registry ins out -> Registry (Inputs a :++ ins) (Output a : out)
register

instance
  (Typeable a, AreSubset ins2 outr out2, insr ~ (ins2 :++ Inputs a), outr ~ (out2 :++ '[Output a])) =>
  AddRegistryLike (Registry ins2 out2) (Typed a) (Registry insr outr)
  where
  <: :: Registry ins2 out2 -> Typed a -> Registry insr outr
(<:) = forall a (ins :: [*]) (out :: [*]).
Typeable a =>
Registry ins out
-> Typed a -> Registry (ins :++ Inputs a) (out :++ '[Output a])
appendUnchecked

instance
  (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)
  where
  <: :: Typed a -> Typed b -> Registry insr outr
(<:) = forall a b (ins :: [*]) (out :: [*]).
(Typeable a, Typeable b, ins ~ (Inputs a :++ Inputs b),
 out ~ '[Output a, Output b]) =>
Typed a -> Typed b -> Registry ins out
addTypedUnchecked

-- Unchecked unification of +: and <+>
infixr 5 <+

-- | Typeclass for appending values and or registries together, without static checks
class AddRegistryUncheckedLike a b c | a b -> c where
  (<+) :: a -> b -> c

instance (insr ~ (ins1 :++ ins2), outr ~ (out1 :++ out2)) => AddRegistryUncheckedLike (Registry ins1 out1) (Registry ins2 out2) (Registry insr outr) where
  <+ :: Registry ins1 out1 -> Registry ins2 out2 -> Registry insr outr
(<+) = forall (is1 :: [*]) (os1 :: [*]) (is2 :: [*]) (os2 :: [*]).
Registry is1 os1
-> Registry is2 os2 -> Registry (is1 :++ is2) (os1 :++ os2)
(<+>)

instance
  (Typeable a, insr ~ (Inputs a :++ ins2), outr ~ (Output a : out2)) =>
  AddRegistryUncheckedLike (Typed a) (Registry ins2 out2) (Registry insr outr)
  where
  <+ :: Typed a -> Registry ins2 out2 -> Registry insr outr
(<+) = forall a (ins :: [*]) (out :: [*]).
Typeable a =>
Typed a
-> Registry ins out -> Registry (Inputs a :++ ins) (Output a : out)
registerUnchecked

instance
  (Typeable a, insr ~ (ins2 :++ Inputs a), outr ~ (out2 :++ '[Output a])) =>
  AddRegistryUncheckedLike (Registry ins2 out2) (Typed a) (Registry insr outr)
  where
  <+ :: Registry ins2 out2 -> Typed a -> Registry insr outr
(<+) = forall a (ins :: [*]) (out :: [*]).
Typeable a =>
Registry ins out
-> Typed a -> Registry (ins :++ Inputs a) (out :++ '[Output a])
appendUnchecked

instance
  (Typeable a, Typeable b, insr ~ (Inputs a :++ Inputs b), outr ~ '[Output a, Output b]) =>
  AddRegistryUncheckedLike (Typed a) (Typed b) (Registry insr outr)
  where
  <+ :: Typed a -> Typed b -> Registry insr outr
(<+) = forall a b (ins :: [*]) (out :: [*]).
(Typeable a, Typeable b, ins ~ (Inputs a :++ Inputs b),
 out ~ '[Output a, Output b]) =>
Typed a -> Typed b -> Registry ins out
addTypedUnchecked

-- | Make the lists of types in the Registry unique, either for better display
--   or for faster compile-time resolution with the make function
normalize :: Registry ins out -> Registry (Normalized ins) (Normalized out)
normalize :: forall (ins :: [*]) (out :: [*]).
Registry ins out -> Registry (Normalized ins) (Normalized out)
normalize (Registry Values
vs Functions
fs Specializations
ss Modifiers
ms) = forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry Values
vs Functions
fs Specializations
ss Modifiers
ms

-- | 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
eraseTypes :: Registry ins out -> Registry '[ERASED_TYPES] '[ERASED_TYPES]
eraseTypes :: forall (ins :: [*]) (out :: [*]).
Registry ins out -> Registry '[ERASED_TYPES] '[ERASED_TYPES]
eraseTypes (Registry Values
values Functions
functions Specializations
specializations Modifiers
modifiers) = forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry Values
values Functions
functions Specializations
specializations Modifiers
modifiers

-- | Singleton type representing erased types
data ERASED_TYPES

-- | 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
safeCoerce :: (IsSameSet out out1) => Registry ins out -> Registry ins1 out1
safeCoerce :: forall (out :: [*]) (out1 :: [*]) (ins :: [*]) (ins1 :: [*]).
IsSameSet out out1 =>
Registry ins out -> Registry ins1 out1
safeCoerce (Registry Values
a Functions
b Specializations
c Modifiers
d) = forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry Values
a Functions
b Specializations
c Modifiers
d

-- | And for extreme cases where you know you're doing the right thing but can't prove it
unsafeCoerce :: Registry ins out -> Registry ins1 out1
unsafeCoerce :: forall (ins :: [*]) (out :: [*]) (ins1 :: [*]) (out1 :: [*]).
Registry ins out -> Registry ins1 out1
unsafeCoerce (Registry Values
a Functions
b Specializations
c Modifiers
d) = forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry Values
a Functions
b Specializations
c Modifiers
d

-- | The empty Registry
end :: Registry '[] '[]
end :: Registry '[] '[]
end = forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry forall a. Monoid a => a
mempty forall a. Monoid a => a
mempty forall a. Monoid a => a
mempty forall a. Monoid a => a
mempty

-- | Create a value which can be added to the Registry
val :: (Typeable a, Show a) => a -> Typed a
val :: forall a. (Typeable a, Show a) => a -> Typed a
val a
a = forall {k} (a :: k). Value -> Typed a
TypedValue (Dynamic -> ValueDescription -> Value
ProvidedValue (forall a. Typeable a => a -> Dynamic
toDyn a
a) (forall a. (Typeable a, Show a) => a -> ValueDescription
describeValue a
a))

-- | Create a value which can be added to the Registry and "lift" it to an 'Applicative' context
valTo :: forall m a. (Applicative m, Typeable a, Typeable (m a), Show a) => a -> Typed (m a)
valTo :: forall (m :: * -> *) a.
(Applicative m, Typeable a, Typeable (m a), Show a) =>
a -> Typed (m a)
valTo a
a = forall {k} (a :: k). Value -> Typed a
TypedValue (forall (m :: * -> *) a.
(Applicative m, Typeable a, Typeable (m a), Show a) =>
a -> Value
liftProvidedValue @m a
a)

-- | Create a "lifted" a Value
liftProvidedValue :: forall m a. (Applicative m, Typeable a, Typeable (m a), Show a) => a -> Value
liftProvidedValue :: forall (m :: * -> *) a.
(Applicative m, Typeable a, Typeable (m a), Show a) =>
a -> Value
liftProvidedValue a
a = Dynamic -> ValueDescription -> Value
ProvidedValue (forall a. Typeable a => a -> Dynamic
toDyn (forall (f :: * -> *) a. Applicative f => a -> f a
pure a
a :: m a)) (forall a. (Typeable a, Show a) => a -> ValueDescription
describeValue a
a)

-- | Create a function which can be added to the Registry
fun :: (Typeable a) => a -> Typed a
fun :: forall a. Typeable a => a -> Typed a
fun a
a = forall {k} (a :: k). Function -> Typed a
TypedFunction (forall f. Typeable f => f -> Function
createFunction a
a)

-- | This is a shortcut to @fun . allTo@ where @allTo@ lifts all the inputs and output
--   to an 'Applicative' context
funTo :: forall m a b. (ApplyVariadic m a b, Typeable a, Typeable b) => a -> Typed b
funTo :: forall (m :: * -> *) a b.
(ApplyVariadic m a b, Typeable a, Typeable b) =>
a -> Typed b
funTo a
a = forall a. Typeable a => a -> Typed a
fun (forall (f :: * -> *) a b. ApplyVariadic f a b => a -> b
allTo @m a
a)

-- | 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
funAs :: forall m a b. (ApplyVariadic1 m a b, Typeable a, Typeable b) => a -> Typed b
funAs :: forall (m :: * -> *) a b.
(ApplyVariadic1 m a b, Typeable a, Typeable b) =>
a -> Typed b
funAs a
a = forall a. Typeable a => a -> Typed a
fun (forall (f :: * -> *) a b. ApplyVariadic1 f a b => a -> b
argsTo @m a
a)

-- | For a given type a being currently built
--   when a value of type b is required pass a specific value
specialize :: forall a b ins out. (Typeable a) => Typed b -> Registry ins out -> Registry ins out
specialize :: forall {k} {k} (a :: k) (b :: k) (ins :: [*]) (out :: [*]).
Typeable a =>
Typed b -> Registry ins out -> Registry ins out
specialize Typed b
b (Registry Values
values Functions
functions (Specializations [Specialization]
c) Modifiers
modifiers) = do
  let ss :: Specializations
ss = [Specialization] -> Specializations
Specializations (SpecializationPath -> Untyped -> Specialization
Specialization (forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall {k} (proxy :: k -> *) (a :: k).
Typeable a =>
proxy a -> SomeTypeRep
someTypeRep (forall {k} (t :: k). Proxy t
Proxy :: Proxy a)) (forall {k} (a :: k). Typed a -> Untyped
untype Typed b
b) forall a. a -> [a] -> [a]
: [Specialization]
c)
  forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry Values
values Functions
functions Specializations
ss Modifiers
modifiers

-- | Specialize a function for a specific path of types
specializePath :: forall path b ins out. (PathToTypeReps path) => Typed b -> Registry ins out -> Registry ins out
specializePath :: forall {k} (path :: [*]) (b :: k) (ins :: [*]) (out :: [*]).
PathToTypeReps path =>
Typed b -> Registry ins out -> Registry ins out
specializePath Typed b
b (Registry Values
values Functions
functions (Specializations [Specialization]
c) Modifiers
modifiers) = do
  let ss :: Specializations
ss = [Specialization] -> Specializations
Specializations (SpecializationPath -> Untyped -> Specialization
Specialization (forall (path :: [*]).
PathToTypeReps path =>
Proxy path -> SpecializationPath
someTypeReps (forall {k} (t :: k). Proxy t
Proxy :: Proxy path)) (forall {k} (a :: k). Typed a -> Untyped
untype Typed b
b) forall a. a -> [a] -> [a]
: [Specialization]
c)
  forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry Values
values Functions
functions Specializations
ss Modifiers
modifiers

-- | Typeclass for extracting type representations out of a list of types
class PathToTypeReps (path :: [Type]) where
  someTypeReps :: Proxy path -> NonEmpty SomeTypeRep

instance {-# OVERLAPPING #-} (Typeable a) => PathToTypeReps '[a] where
  someTypeReps :: Proxy '[a] -> SpecializationPath
someTypeReps = forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall {k} (proxy :: k -> *) (a :: k).
Typeable a =>
proxy a -> SomeTypeRep
someTypeRep (forall {k} (t :: k). Proxy t
Proxy :: Proxy a))

instance (Typeable a, PathToTypeReps rest) => PathToTypeReps (a : rest) where
  someTypeReps :: Proxy (a : rest) -> SpecializationPath
someTypeReps = forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ forall {k} (proxy :: k -> *) (a :: k).
Typeable a =>
proxy a -> SomeTypeRep
someTypeRep (forall {k} (t :: k). Proxy t
Proxy :: Proxy a) forall a. a -> [a] -> NonEmpty a
:| forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (forall (path :: [*]).
PathToTypeReps path =>
Proxy path -> SpecializationPath
someTypeReps (forall {k} (t :: k). Proxy t
Proxy :: Proxy rest))

-- | Once a value has been computed allow to modify it before storing it
--   This keeps the same registry type
tweak :: forall a ins out. (Typeable a) => (a -> a) -> Registry ins out -> Registry ins out
tweak :: forall a (ins :: [*]) (out :: [*]).
Typeable a =>
(a -> a) -> Registry ins out -> Registry ins out
tweak a -> a
f (Registry Values
values Functions
functions Specializations
specializations (Modifiers [(SomeTypeRep, ModifierFunction)]
mf)) =
  forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry
    Values
values
    Functions
functions
    Specializations
specializations
    ([(SomeTypeRep, ModifierFunction)] -> Modifiers
Modifiers ((forall {k} (proxy :: k -> *) (a :: k).
Typeable a =>
proxy a -> SomeTypeRep
someTypeRep (forall {k} (t :: k). Proxy t
Proxy :: Proxy a), forall f. Typeable f => f -> ModifierFunction
createConstModifierFunction a -> a
f) forall a. a -> [a] -> [a]
: [(SomeTypeRep, ModifierFunction)]
mf))

-- * Memoization

-- | Instantiating components can trigger side-effects
--   The way the resolution algorithm works a component of type `m a` will be
--   re-executed *every time* it is needed as a given dependency
--   This section adds support for memoizing those actions

-- | 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!
memoize :: forall m a ins out. (MonadIO m, Typeable a, Typeable (m a)) => Registry ins out -> IO (Registry ins out)
memoize :: forall (m :: * -> *) a (ins :: [*]) (out :: [*]).
(MonadIO m, Typeable a, Typeable (m a)) =>
Registry ins out -> IO (Registry ins out)
memoize (Registry Values
values Functions
functions Specializations
specializations (Modifiers [(SomeTypeRep, ModifierFunction)]
mf)) = do
  Cache a
cache <- forall a. IO (Cache a)
newCache @a
  let modifiers :: Modifiers
modifiers = [(SomeTypeRep, ModifierFunction)] -> Modifiers
Modifiers ((forall {k} (proxy :: k -> *) (a :: k).
Typeable a =>
proxy a -> SomeTypeRep
someTypeRep (forall {k} (t :: k). Proxy t
Proxy :: Proxy (m a)), forall f. Typeable f => f -> Function
createFunction forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a (m :: * -> *).
(MonadIO m, Typeable a) =>
Cache a -> Key -> m a -> m a
fetch @a @m Cache a
cache) forall a. a -> [a] -> [a]
: [(SomeTypeRep, ModifierFunction)]
mf)
  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall (inputs :: [*]) (outputs :: [*]).
Values
-> Functions
-> Specializations
-> Modifiers
-> Registry inputs outputs
Registry Values
values Functions
functions Specializations
specializations Modifiers
modifiers

-- | 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`)
memoizeAll :: forall m ins out. (MonadIO m, MemoizedActions out) => Registry ins out -> IO (Registry ins out)
memoizeAll :: forall (m :: * -> *) (ins :: [*]) (out :: [*]).
(MonadIO m, MemoizedActions out) =>
Registry ins out -> IO (Registry ins out)
memoizeAll Registry ins out
r =
  forall (todo :: [*]) (ins :: [*]) (out :: [*]).
MemoizeRegistry todo ins out -> Registry ins out
_unMemoizeRegistry
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (ls :: [*]) (ins :: [*]) (out :: [*]).
MemoizedActions ls =>
MemoizeRegistry ls ins out -> IO (MemoizeRegistry '[] ins out)
memoizeActions (forall (ins :: [*]) (out :: [*]).
Registry ins out -> MemoizeRegistry out ins out
startMemoizeRegistry Registry ins out
r)

-- | Registry where all output values are memoized
newtype MemoizeRegistry (todo :: [Type]) (ins :: [Type]) (out :: [Type]) = MemoizeRegistry {forall (todo :: [*]) (ins :: [*]) (out :: [*]).
MemoizeRegistry todo ins out -> Registry ins out
_unMemoizeRegistry :: Registry ins out}

-- | Prepare a Registry for memoization
startMemoizeRegistry :: Registry ins out -> MemoizeRegistry out ins out
startMemoizeRegistry :: forall (ins :: [*]) (out :: [*]).
Registry ins out -> MemoizeRegistry out ins out
startMemoizeRegistry = forall (todo :: [*]) (ins :: [*]) (out :: [*]).
Registry ins out -> MemoizeRegistry todo ins out
MemoizeRegistry

-- | Prepare a Registry for memoization for a specific list of types
makeMemoizeRegistry :: forall todo ins out. Registry ins out -> MemoizeRegistry todo ins out
makeMemoizeRegistry :: forall (todo :: [*]) (ins :: [*]) (out :: [*]).
Registry ins out -> MemoizeRegistry todo ins out
makeMemoizeRegistry = forall (todo :: [*]) (ins :: [*]) (out :: [*]).
Registry ins out -> MemoizeRegistry todo ins out
MemoizeRegistry @todo

-- | This typeclass take an existing registry and memoize values created for the ls types
class MemoizedActions ls where
  memoizeActions :: MemoizeRegistry ls ins out -> IO (MemoizeRegistry '[] ins out)

-- | If the list of types is empty there is nothing to memoize
instance MemoizedActions '[] where
  memoizeActions :: forall (ins :: [*]) (out :: [*]).
MemoizeRegistry '[] ins out -> IO (MemoizeRegistry '[] ins out)
memoizeActions = forall (f :: * -> *) a. Applicative f => a -> f a
pure

-- | If the type represents an effectful value, memoize it and recurse with the rest
instance {-# OVERLAPPING #-} (MonadIO m, Typeable a, Typeable (m a), MemoizedActions rest) => MemoizedActions (m a : rest) where
  memoizeActions :: forall (ins :: [*]) (out :: [*]).
MemoizeRegistry (m a : rest) ins out
-> IO (MemoizeRegistry '[] ins out)
memoizeActions (MemoizeRegistry Registry ins out
r) = do
    Registry ins out
r' <- forall (m :: * -> *) a (ins :: [*]) (out :: [*]).
(MonadIO m, Typeable a, Typeable (m a)) =>
Registry ins out -> IO (Registry ins out)
memoize @m @a Registry ins out
r
    forall (ls :: [*]) (ins :: [*]) (out :: [*]).
MemoizedActions ls =>
MemoizeRegistry ls ins out -> IO (MemoizeRegistry '[] ins out)
memoizeActions (forall (todo :: [*]) (ins :: [*]) (out :: [*]).
Registry ins out -> MemoizeRegistry todo ins out
makeMemoizeRegistry @rest Registry ins out
r')

-- | If the type represents a pure value, memoize the rest
instance (MemoizedActions rest) => MemoizedActions (a : rest) where
  memoizeActions :: forall (ins :: [*]) (out :: [*]).
MemoizeRegistry (a : rest) ins out
-> IO (MemoizeRegistry '[] ins out)
memoizeActions (MemoizeRegistry Registry ins out
r) =
    forall (ls :: [*]) (ins :: [*]) (out :: [*]).
MemoizedActions ls =>
MemoizeRegistry ls ins out -> IO (MemoizeRegistry '[] ins out)
memoizeActions (forall (todo :: [*]) (ins :: [*]) (out :: [*]).
Registry ins out -> MemoizeRegistry todo ins out
makeMemoizeRegistry @rest Registry ins out
r)