diff --git a/registry.cabal b/registry.cabal
--- a/registry.cabal
+++ b/registry.cabal
@@ -4,10 +4,10 @@
 --
 -- see: https://github.com/sol/hpack
 --
--- hash: ae5e25537d62d420d9fa82531a22426aa1bd8507f6bff266176de9eda97dba39
+-- hash: fa621a560c312bba02cbbb23e0bcdeb93cf048b5c69ea7d4405a73f9bbe77db8
 
 name:           registry
-version:        0.3.0.7
+version:        0.3.0.8
 synopsis:       data structure for assembling components
 description:    This library provides a "Registry" which is a data structure containing a list of functions and values representing dependencies in a directed acyclic graph. A `make` function can then be used to create a value of a specific type out of the registry.
                 You can start with the [README](https://github.com/etorreborre/registry/blob/master/README.md) for a full description of the library.
diff --git a/src/Data/Registry/RIO.hs b/src/Data/Registry/RIO.hs
--- a/src/Data/Registry/RIO.hs
+++ b/src/Data/Registry/RIO.hs
@@ -9,10 +9,7 @@
 type RIO = ResourceT IO
 
 -- | This function must be used to run services involving a top component
---   It creates the top component and invokes all warmup functions
---
---   The passed function 'f' is used to decide whether to continue or
---   not depending on the Result
+--   It creates an application of type a and which can return a result of type b.
 --
 --   We also make sure that all effects are memoized by calling `memoizeAll` on the Registry here!
 withRegistry ::
diff --git a/src/Data/Registry/Registry.hs b/src/Data/Registry/Registry.hs
--- a/src/Data/Registry/Registry.hs
+++ b/src/Data/Registry/Registry.hs
@@ -102,25 +102,32 @@
 --   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 :: (Typeable a, IsSubset (Inputs a) out a) => Typed a -> Registry ins out -> Registry (Inputs a :++ ins) (Output a ': out)
 register = 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 :: (Typeable a) => Typed a -> Registry ins out -> Registry (Inputs a :++ ins) (Output a ': out)
 registerUnchecked (TypedValue v) (Registry (Values vs) functions specializations modifiers) =
   Registry (Values (v : vs)) functions specializations modifiers
 registerUnchecked (TypedFunction f) (Registry (Values vs) (Functions fs) specializations modifiers) =
   Registry (Values vs) (Functions (f : fs)) specializations 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 (Registry (Values vs) functions specializations modifiers) (TypedValue v) =
+  Registry (Values (vs <> [v])) functions specializations modifiers
+appendUnchecked (Registry (Values vs) (Functions fs) specializations modifiers) (TypedFunction f) =
+  Registry (Values vs) (Functions (fs <> [f])) specializations 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 (TypedValue v1) (TypedValue v2) = Registry (Values [v1, v2]) mempty mempty mempty
+addTypedUnchecked (TypedValue v1) (TypedFunction f2) = Registry (Values [v1]) (Functions [f2]) mempty mempty
+addTypedUnchecked (TypedFunction f1) (TypedValue v2) = Registry (Values [v2]) (Functions [f1]) mempty mempty
+addTypedUnchecked (TypedFunction f1) (TypedFunction f2) = Registry mempty (Functions [f1, f2]) mempty 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 +:
@@ -144,16 +151,16 @@
   (<:) = register
 
 instance
-  (Typeable a, IsSubset (Inputs a) out2 a, insr ~ (Inputs a :++ ins2), outr ~ (Output a : out2)) =>
+  (Typeable a, IsSubset (Inputs a) out2 a, insr ~ (ins2 :++ Inputs a), outr ~ (out2 :++ '[Output a])) =>
   AddRegistryLike (Registry ins2 out2) (Typed a) (Registry insr outr)
   where
-  (<:) = flip register
+  (<:) = appendUnchecked
 
 instance
-  (Typeable a, IsSubset (Inputs a) '[Output b] a, Inputs b ~ '[], Typeable b, insr ~ (Inputs a :++ (Inputs b :++ '[])), outr ~ (Output a : '[Output b])) =>
+  (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
-  (<:) a b = register a (register b end)
+  (<:) a b = addTypedUnchecked a b
 
 -- Unchecked unification of +: and <+>
 infixr 5 <+
@@ -171,16 +178,16 @@
   (<+) = registerUnchecked
 
 instance
-  (Typeable a, insr ~ (Inputs a :++ ins2), outr ~ (Output a : out2)) =>
+  (Typeable a, insr ~ (ins2 :++ Inputs a), outr ~ (out2 :++ '[Output a])) =>
   AddRegistryUncheckedLike (Registry ins2 out2) (Typed a) (Registry insr outr)
   where
-  (<+) = flip registerUnchecked
+  (<+) = appendUnchecked
 
 instance
-  (Typeable a, Typeable b, insr ~ (Inputs a :++ (Inputs b :++ '[])), outr ~ (Output a : '[Output b])) =>
+  (Typeable a, Typeable b, insr ~ (Inputs a :++ Inputs b), outr ~ '[Output a, Output b]) =>
   AddRegistryUncheckedLike (Typed a) (Typed b) (Registry insr outr)
   where
-  (<+) a b = registerUnchecked a (registerUnchecked b end)
+  (<+) a b = addTypedUnchecked a b
 
 -- | Make the lists of types in the Registry unique, either for better display
 --   or for faster compile-time resolution with the make function
@@ -207,7 +214,7 @@
 
 -- | The empty Registry
 end :: Registry '[] '[]
-end = Registry (Values []) (Functions []) (Specializations []) (Modifiers [])
+end = Registry mempty mempty mempty mempty
 
 -- | Create a value which can be added to the 'Registry'
 val :: (Typeable a, Show a) => a -> Typed a
diff --git a/src/Data/Registry/Solver.hs b/src/Data/Registry/Solver.hs
--- a/src/Data/Registry/Solver.hs
+++ b/src/Data/Registry/Solver.hs
@@ -51,6 +51,9 @@
 
 instance IsSubset '[] out t
 
+-- | The 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
 instance (CanMake a out t, IsSubset els out t) => IsSubset (a ': els) out t
 
 -- | Compute if each element of a list of types
diff --git a/test/Test/Data/Registry/RegistrySpec.hs b/test/Test/Data/Registry/RegistrySpec.hs
--- a/test/Test/Data/Registry/RegistrySpec.hs
+++ b/test/Test/Data/Registry/RegistrySpec.hs
@@ -22,6 +22,27 @@
   result <- liftIO $ readIORef ref
   result === "hey"
 
+test_append_values = test "2 values can be appended together" $ do
+  let r = val (1 :: Int) <: val (2 :: Int)
+  make @Int r === 1
+
+  let r2 = val (1 :: Int) <+ val (2 :: Int)
+  make @Int r2 === 1
+
+test_append_value_to_registry = test "a value can be appended to a registry" $ do
+  let r = (val (1 :: Int) <: val (2 :: Int)) <: val (3 :: Int)
+  make @Int r === 1
+
+  let r2 = (val (1 :: Int) <+ val (2 :: Int)) <+ val (3 :: Int)
+  make @Int r2 === 1
+
+test_prepend_value_to_registry = test "a value can be prepended to a registry" $ do
+  let r = val (1 :: Int) <: (val (2 :: Int) <: val (3 :: Int))
+  make @Int r === 1
+
+  let r2 = val (1 :: Int) <+ (val (2 :: Int) <+ val (3 :: Int))
+  make @Int r2 === 1
+
 -- *
 
 newtype Logger = Logger {info :: Text -> IO ()}
@@ -45,6 +66,15 @@
       <: (val ("t" :: Text) +: end)
       <: (val ("t" :: Text) +: end)
       <: val ("t" :: Text)
+
+registry2 :: Registry '[] [Text, Text]
+registry2 =
+  val ("t" :: Text)
+    <: val ("t" :: Text)
+
+registry3 :: Registry '[] '[Int] =
+  val (10 :: Int)
+    <+ end
 
 -- * COMPILATION CHECK LIFTING (see #7)