-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Type-indexed maps
--   
--   Maps where keys are types and values can have types depending on their
--   keys.
@package type-map
@version 0.1.7.0

module Data.TypeMap.Internal.Dynamic

-- | Map from types <tt>t</tt> of kind <tt>*</tt> to values of type
--   <tt>Item x t</tt>.
newtype TypeMap x
TypeMap :: Map TypeRep Any -> TypeMap x

-- | An extensible type family mapping types (as keys) to types of values,
--   parameterized by types <tt>x</tt>.
type family Item x t

-- | A constant mapping to type <tt>a</tt>. <tt><a>TypeMap</a>
--   (<a>OfType</a> a)</tt> is the type of maps from types to values of
--   type <tt>a</tt>.
data OfType a

-- | Whether the map is empty.
null :: TypeMap x -> Bool

-- | The number of elements in the map.
size :: TypeMap x -> Int

-- | Empty type map.
empty :: TypeMap x

-- | Insert an element indexed by type <tt>t</tt>.
insert :: forall t x proxy. Typeable t => proxy t -> Item x t -> TypeMap x -> TypeMap x

-- | Infix version of <a>insert</a> to facilitate a literal-ish syntax:
--   
--   <pre>
--   <a>empty</a>
--     <a>&lt;:</a> (<a>Proxy</a> <tt>k1, v1)
--     <a>&lt;:</a> (<a>Proxy</a> </tt>k2, v2)
--   </pre>
(<:) :: forall t x proxy. Typeable t => TypeMap x -> (proxy t, Item x t) -> TypeMap x

-- | Update an element indexed by type <tt>t</tt>.
update :: forall t x proxy. Typeable t => proxy t -> (Item x t -> Maybe (Item x t)) -> TypeMap x -> TypeMap x

-- | Update a (possibly absent) element indexed by type <tt>t</tt>.
alter :: forall t x proxy. Typeable t => proxy t -> (Maybe (Item x t) -> Maybe (Item x t)) -> TypeMap x -> TypeMap x

-- | Lookup an element indexed by type <tt>t</tt>.
lookup :: forall t x proxy. Typeable t => proxy t -> TypeMap x -> Maybe (Item x t)

-- | Delete a key and its value from the map. Does nothing if the key does
--   not exist.
delete :: forall t x proxy. Typeable t => proxy t -> TypeMap x -> TypeMap x

-- | Left-biased union of two maps; it keeps the first key if duplicates
--   are found.
union :: forall x. TypeMap x -> TypeMap x -> TypeMap x

-- | Difference of two maps; keep elements of the first map which are not
--   in the second.
difference :: forall x. TypeMap x -> TypeMap x -> TypeMap x

-- | Intersection of two maps; keep elements of the first map which are
--   also in the second.
intersection :: forall x y. TypeMap x -> TypeMap y -> TypeMap x

-- | Map a function on all elements.
map :: forall x y. (forall t. Typeable t => Proxy t -> Item x t -> Item y t) -> TypeMap x -> TypeMap y

-- | Reduce a constant type map into a plain list of values.
toList :: forall r. TypeMap (OfType r) -> [r]

-- | Collapse a type map into a plain list of values.
toListMap :: forall tm r. (forall t. Proxy t -> Item tm t -> r) -> TypeMap tm -> [r]

-- | Traverse the type map. (<a>map</a> with effects.)
traverse :: forall f x y. Applicative f => (forall t. Typeable t => Proxy t -> Item x t -> f (Item y t)) -> TypeMap x -> f (TypeMap y)
type family Typed x t
type family UnTyped x
data ItemFun x y
data ItemKleisli (f :: * -> *) x y
withTypeRep :: forall x proxy. (forall t. Typeable t => Proxy t -> Typed x t) -> proxy x -> TypeRep -> UnTyped x

module Data.TypeMap.Dynamic

-- | Map from types <tt>t</tt> of kind <tt>*</tt> to values of type
--   <tt>Item x t</tt>.
data TypeMap x

-- | An extensible type family mapping types (as keys) to types of values,
--   parameterized by types <tt>x</tt>.
type family Item x t

-- | Empty type map.
empty :: TypeMap x

-- | Whether the map is empty.
null :: TypeMap x -> Bool

-- | The number of elements in the map.
size :: TypeMap x -> Int

-- | Insert an element indexed by type <tt>t</tt>.
insert :: forall t x proxy. Typeable t => proxy t -> Item x t -> TypeMap x -> TypeMap x

-- | Infix version of <a>insert</a> to facilitate a literal-ish syntax:
--   
--   <pre>
--   <a>empty</a>
--     <a>&lt;:</a> (<a>Proxy</a> <tt>k1, v1)
--     <a>&lt;:</a> (<a>Proxy</a> </tt>k2, v2)
--   </pre>
(<:) :: forall t x proxy. Typeable t => TypeMap x -> (proxy t, Item x t) -> TypeMap x

-- | Update an element indexed by type <tt>t</tt>.
update :: forall t x proxy. Typeable t => proxy t -> (Item x t -> Maybe (Item x t)) -> TypeMap x -> TypeMap x

-- | Update a (possibly absent) element indexed by type <tt>t</tt>.
alter :: forall t x proxy. Typeable t => proxy t -> (Maybe (Item x t) -> Maybe (Item x t)) -> TypeMap x -> TypeMap x

-- | Lookup an element indexed by type <tt>t</tt>.
lookup :: forall t x proxy. Typeable t => proxy t -> TypeMap x -> Maybe (Item x t)

-- | Delete a key and its value from the map. Does nothing if the key does
--   not exist.
delete :: forall t x proxy. Typeable t => proxy t -> TypeMap x -> TypeMap x

-- | Map a function on all elements.
map :: forall x y. (forall t. Typeable t => Proxy t -> Item x t -> Item y t) -> TypeMap x -> TypeMap y

-- | Traverse the type map. (<a>map</a> with effects.)
traverse :: forall f x y. Applicative f => (forall t. Typeable t => Proxy t -> Item x t -> f (Item y t)) -> TypeMap x -> f (TypeMap y)

-- | Reduce a constant type map into a plain list of values.
toList :: forall r. TypeMap (OfType r) -> [r]

-- | Collapse a type map into a plain list of values.
toListMap :: forall tm r. (forall t. Proxy t -> Item tm t -> r) -> TypeMap tm -> [r]

-- | Left-biased union of two maps; it keeps the first key if duplicates
--   are found.
union :: forall x. TypeMap x -> TypeMap x -> TypeMap x

-- | Difference of two maps; keep elements of the first map which are not
--   in the second.
difference :: forall x. TypeMap x -> TypeMap x -> TypeMap x

-- | Intersection of two maps; keep elements of the first map which are
--   also in the second.
intersection :: forall x y. TypeMap x -> TypeMap y -> TypeMap x

-- | A constant mapping to type <tt>a</tt>. <tt><a>TypeMap</a>
--   (<a>OfType</a> a)</tt> is the type of maps from types to values of
--   type <tt>a</tt>.
data OfType a

module Data.TypeMap.Internal.Dynamic.Alt

-- | Insert an element indexed by type <tt>t</tt>.
insert :: forall t x. Typeable t => Item x t -> TypeMap x -> TypeMap x

-- | Infix version of <a>insert</a> to facilitate a literal-ish syntax:
--   
--   <pre>
--   <a>empty</a>
--     <a>&lt;:</a> <a>at</a> <tt>t1 v1
--     <a>&lt;:</a> <a>at</a> </tt>t2 v2
--   </pre>
(<:) :: forall t x proxy. Typeable t => TypeMap x -> (proxy t, Item x t) -> TypeMap x

-- | See <tt>(<a>&lt;:</a>)</tt>.
at :: forall t a. Typeable t => a -> (Proxy t, a)

-- | Update an element indexed by type <tt>t</tt>.
update :: forall t x. Typeable t => (Item x t -> Maybe (Item x t)) -> TypeMap x -> TypeMap x

-- | Update a (possibly absent) element indexed by type <tt>t</tt>.
alter :: forall t x. Typeable t => (Maybe (Item x t) -> Maybe (Item x t)) -> TypeMap x -> TypeMap x

-- | Lookup an element indexed by type <tt>t</tt>.
lookup :: forall t x. Typeable t => TypeMap x -> Maybe (Item x t)

-- | Delete a key and its value from the map. Does nothing if the key does
--   not exist.
delete :: forall t x. Typeable t => TypeMap x -> TypeMap x

-- | Map a function on all elements.
map :: forall x y. (forall t. Typeable t => Item x t -> Item y t) -> TypeMap x -> TypeMap y

-- | Traverse the type map. (<a>map</a> with effects.)
traverse :: forall f x y. Applicative f => (forall t. Typeable t => Item x t -> f (Item y t)) -> TypeMap x -> f (TypeMap y)
newtype Typed_ x t
Typed_ :: Typed x t -> Typed_ x t
withTypeRep :: forall x. (forall t. Typeable t => Typed_ x t) -> TypeRep -> UnTyped x


-- | Type-application-based interface.
--   
--   <pre>
--   {-# LANGUAGE TypeApplications #-}
--   </pre>
module Data.TypeMap.Dynamic.Alt

-- | Map from types <tt>t</tt> of kind <tt>*</tt> to values of type
--   <tt>Item x t</tt>.
data TypeMap x

-- | An extensible type family mapping types (as keys) to types of values,
--   parameterized by types <tt>x</tt>.
type family Item x t

-- | Empty type map.
empty :: TypeMap x

-- | Whether the map is empty.
null :: TypeMap x -> Bool

-- | The number of elements in the map.
size :: TypeMap x -> Int

-- | Insert an element indexed by type <tt>t</tt>.
insert :: forall t x. Typeable t => Item x t -> TypeMap x -> TypeMap x

-- | Infix version of <a>insert</a> to facilitate a literal-ish syntax:
--   
--   <pre>
--   <a>empty</a>
--     <a>&lt;:</a> <a>at</a> <tt>t1 v1
--     <a>&lt;:</a> <a>at</a> </tt>t2 v2
--   </pre>
(<:) :: forall t x proxy. Typeable t => TypeMap x -> (proxy t, Item x t) -> TypeMap x

-- | See <tt>(<a>&lt;:</a>)</tt>.
at :: forall t a. Typeable t => a -> (Proxy t, a)

-- | Update an element indexed by type <tt>t</tt>.
update :: forall t x. Typeable t => (Item x t -> Maybe (Item x t)) -> TypeMap x -> TypeMap x

-- | Update a (possibly absent) element indexed by type <tt>t</tt>.
alter :: forall t x. Typeable t => (Maybe (Item x t) -> Maybe (Item x t)) -> TypeMap x -> TypeMap x

-- | Lookup an element indexed by type <tt>t</tt>.
lookup :: forall t x. Typeable t => TypeMap x -> Maybe (Item x t)

-- | Delete a key and its value from the map. Does nothing if the key does
--   not exist.
delete :: forall t x. Typeable t => TypeMap x -> TypeMap x

-- | Map a function on all elements.
map :: forall x y. (forall t. Typeable t => Item x t -> Item y t) -> TypeMap x -> TypeMap y

-- | Traverse the type map. (<a>map</a> with effects.)
traverse :: forall f x y. Applicative f => (forall t. Typeable t => Item x t -> f (Item y t)) -> TypeMap x -> f (TypeMap y)

-- | Reduce a constant type map into a plain list of values.
toList :: forall r. TypeMap (OfType r) -> [r]

-- | Collapse a type map into a plain list of values.
toListMap :: forall tm r. (forall t. Proxy t -> Item tm t -> r) -> TypeMap tm -> [r]

-- | Left-biased union of two maps; it keeps the first key if duplicates
--   are found.
union :: forall x. TypeMap x -> TypeMap x -> TypeMap x

-- | Difference of two maps; keep elements of the first map which are not
--   in the second.
difference :: forall x. TypeMap x -> TypeMap x -> TypeMap x

-- | Intersection of two maps; keep elements of the first map which are
--   also in the second.
intersection :: forall x y. TypeMap x -> TypeMap y -> TypeMap x

-- | A constant mapping to type <tt>a</tt>. <tt><a>TypeMap</a>
--   (<a>OfType</a> a)</tt> is the type of maps from types to values of
--   type <tt>a</tt>.
data OfType a

module Data.TypeMap.Internal.Unsafe

-- | All elements except the last one.
type family Init (d :: [k])

-- | Last element of a list.
type family Last (d :: [k])

-- | Append a type to a list.
type family Snoc (d :: [k]) (a :: k)

-- | Type associated with <tt>a</tt> in <tt>d</tt>. If the key <tt>a</tt>
--   occurs multiple times, the first one is used.
type family Lookup (a :: k) (d :: [(k, *)])

-- | Index of type key <tt>a</tt> in association list <tt>d</tt>.
type family Index (a :: k) (d :: [(k, *)])

-- | Helper to define <tt>index</tt> functions.
unsafeIndex :: forall a d f m. (KnownNat (Index a d), Coercible (f Any) (m d)) => (forall c. f c -> Int -> c) -> m d -> Lookup a d

-- | Helper to define <tt>cons</tt> functions.
unsafeCons :: forall a d b f m. (Coercible (f Any) (m d), Coercible (f Any) (m ('(a, b) : d))) => (forall c. c -> f c -> f c) -> b -> m d -> m ('(a, b) : d)

-- | Helper to define <tt>snoc</tt> functions.
unsafeSnoc :: forall a d b f m. (Last d ~ '(a, b), Coercible (f Any) (m (Init d)), Coercible (f Any) (m d)) => (forall c. f c -> c -> f c) -> m (Init d) -> b -> m d

-- | This class gives the integer associated with a type-level natural.
--   There are instances of the class for every concrete literal: 0, 1, 2,
--   etc.
class KnownNat (n :: Nat)

-- | The type constructor <a>Any</a> is type to which you can unsafely
--   coerce any lifted type, and back. More concretely, for a lifted type
--   <tt>t</tt> and value <tt>x :: t</tt>, -- <tt>unsafeCoerce
--   (unsafeCoerce x :: Any) :: t</tt> is equivalent to <tt>x</tt>.
type family Any :: k
unsafeCoerce :: a -> b

-- | <a>Proxy</a> is a type that holds no data, but has a phantom parameter
--   of arbitrary type (or even kind). Its use is to provide type
--   information, even though there is no value available of that type (or
--   it may be too costly to create one).
--   
--   Historically, <tt><a>Proxy</a> :: <a>Proxy</a> a</tt> is a safer
--   alternative to the <tt><a>undefined</a> :: a</tt> idiom.
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy (Void, Int -&gt; Int)
--   Proxy
--   </pre>
--   
--   Proxy can even hold types of higher kinds,
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy Either
--   Proxy
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy Functor
--   Proxy
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy complicatedStructure
--   Proxy
--   </pre>
data Proxy (t :: k)
Proxy :: Proxy (t :: k)

module Data.TypeMap.Internal.Map

-- | IntMap-backed type-map.
data TypeMap d
TypeMap :: !Int -> !TypeMap' d -> !Int -> TypeMap d
newtype TypeMap' d
TypeMap' :: IntMap Any -> TypeMap' d

-- | Empty vector.
empty :: TypeMap '[]

-- | Access an element indexed by type <tt>a</tt>. <i>O(log n)</i>
--   
--   If <tt>a</tt> is associated to <tt>b</tt> in the type list <tt>d</tt>:
--   
--   <pre>
--   <a>index</a> @a (v :: <a>TypeMap</a> d) :: b
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let v = (0 :: Int) &lt;| True &lt;| "Hello" &lt;| empty :: TypeMap '[ '("a", Int), '("b", Bool), '("c", String)]
--   
--   &gt;&gt;&gt; index @"c" v
--   "Hello"
--   </pre>
index :: forall a d. KnownNat (Index a d) => TypeMap d -> Lookup a d

-- | Add an element to the beginning of a map. <i>O(log n)</i>
cons :: forall a d b. b -> TypeMap d -> TypeMap ('(a, b) : d)
infixr 5 `cons`

-- | Synonym of <a>cons</a>.
(<|) :: forall a d b. b -> TypeMap d -> TypeMap ('(a, b) : d)
infixr 5 <|

-- | Add an element to the end of a list. <i>O(log n)</i>
snoc :: forall a d b. Last d ~ '(a, b) => TypeMap (Init d) -> b -> TypeMap d
infixl 5 `snoc`

-- | Synonym of <a>snoc</a>.
(|>) :: forall a d b. Last d ~ '(a, b) => TypeMap (Init d) -> b -> TypeMap d
infixl 5 |>

module Data.TypeMap.Internal.List

-- | List-backed type-map.
newtype TypeList d
TypeList :: [Any] -> TypeList d

-- | Empty list.
empty :: TypeList '[]

-- | Access an element indexed by its type <tt>a</tt>. <i>O(n)</i>
--   
--   If <tt>a</tt> is associated to <tt>b</tt> in the type list <tt>d</tt>:
--   
--   <pre>
--   <a>index</a> @a (l :: <a>TypeList</a> d) :: b
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let l = (0 :: Int) &lt;| True &lt;| "Hello" &lt;| empty :: TypeList '[ '("a", Int), '("b", Bool), '("c", String)]
--   
--   &gt;&gt;&gt; index @"c" l
--   "Hello"
--   </pre>
index :: forall a d. KnownNat (Index a d) => TypeList d -> Lookup a d

-- | Add an element to the beginning of a list. <i>O(1)</i>
cons :: forall a d b. b -> TypeList d -> TypeList ('(a, b) : d)
infixr 5 `cons`

-- | Synonym of <a>cons</a>.
(<|) :: forall a d b. b -> TypeList d -> TypeList ('(a, b) : d)
infixr 5 <|

-- | Add an element to the end of a list. <i>O(n)</i>
snoc :: forall a d b. Last d ~ '(a, b) => TypeList (Init d) -> b -> TypeList d
infixr 5 `snoc`

-- | Synonym of <a>snoc</a>.
(|>) :: forall a d b. Last d ~ '(a, b) => TypeList (Init d) -> b -> TypeList d
infixr 5 |>

module Data.TypeMap.Internal.Vector

-- | Vector-backed type-map.
newtype TypeVector d
TypeVector :: Vector Any -> TypeVector d

-- | Empty vector.
empty :: TypeVector '[]

-- | Access an element indexed by type <tt>a</tt>. <i>O(1)</i>
--   
--   If <tt>a</tt> is associated to <tt>b</tt> in the type list <tt>d</tt>:
--   
--   <pre>
--   <a>index</a> @a (v :: <a>TypeVector</a> d) :: b
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let v = (0 :: Int) &lt;| True &lt;| "Hello" &lt;| empty :: TypeVector '[ '("a", Int), '("b", Bool), '("c", String)]
--   
--   &gt;&gt;&gt; index @"c" v
--   "Hello"
--   </pre>
index :: forall a d. KnownNat (Index a d) => TypeVector d -> Lookup a d

-- | Add an element to the beginning of a vector. <i>O(n)</i>
cons :: forall a d b. b -> TypeVector d -> TypeVector ('(a, b) : d)
infixr 5 `cons`

-- | Synonym of <a>cons</a>.
(<|) :: forall a d b. b -> TypeVector d -> TypeVector ('(a, b) : d)
infixr 5 <|

-- | Add an element to the end of a vector. <i>O(n)</i>
snoc :: forall a d b. Last d ~ '(a, b) => TypeVector (Init d) -> b -> TypeVector d
infixr 5 `snoc`

-- | Synonym of <a>snoc</a>.
(|>) :: forall a d b. Last d ~ '(a, b) => TypeVector (Init d) -> b -> TypeVector d
infixr 5 |>

module Data.TypeMap.List

-- | List-backed type-map.
data TypeList d

-- | Empty list.
empty :: TypeList '[]

-- | Access an element indexed by its type <tt>a</tt>. <i>O(n)</i>
--   
--   If <tt>a</tt> is associated to <tt>b</tt> in the type list <tt>d</tt>:
--   
--   <pre>
--   <a>index</a> @a (l :: <a>TypeList</a> d) :: b
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let l = (0 :: Int) &lt;| True &lt;| "Hello" &lt;| empty :: TypeList '[ '("a", Int), '("b", Bool), '("c", String)]
--   
--   &gt;&gt;&gt; index @"c" l
--   "Hello"
--   </pre>
index :: forall a d. KnownNat (Index a d) => TypeList d -> Lookup a d

-- | Add an element to the beginning of a list. <i>O(1)</i>
cons :: forall a d b. b -> TypeList d -> TypeList ('(a, b) : d)
infixr 5 `cons`

-- | Synonym of <a>cons</a>.
(<|) :: forall a d b. b -> TypeList d -> TypeList ('(a, b) : d)
infixr 5 <|

-- | Add an element to the end of a list. <i>O(n)</i>
snoc :: forall a d b. Last d ~ '(a, b) => TypeList (Init d) -> b -> TypeList d
infixr 5 `snoc`

-- | Synonym of <a>snoc</a>.
(|>) :: forall a d b. Last d ~ '(a, b) => TypeList (Init d) -> b -> TypeList d
infixr 5 |>

-- | Convert from a list to a vector.
toVector :: TypeList d -> TypeVector d

module Data.TypeMap.Map

-- | IntMap-backed type-map.
data TypeMap d

-- | Empty vector.
empty :: TypeMap '[]

-- | Access an element indexed by type <tt>a</tt>. <i>O(log n)</i>
--   
--   If <tt>a</tt> is associated to <tt>b</tt> in the type list <tt>d</tt>:
--   
--   <pre>
--   <a>index</a> @a (v :: <a>TypeMap</a> d) :: b
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let v = (0 :: Int) &lt;| True &lt;| "Hello" &lt;| empty :: TypeMap '[ '("a", Int), '("b", Bool), '("c", String)]
--   
--   &gt;&gt;&gt; index @"c" v
--   "Hello"
--   </pre>
index :: forall a d. KnownNat (Index a d) => TypeMap d -> Lookup a d

-- | Add an element to the beginning of a map. <i>O(log n)</i>
cons :: forall a d b. b -> TypeMap d -> TypeMap ('(a, b) : d)
infixr 5 `cons`

-- | Synonym of <a>cons</a>.
(<|) :: forall a d b. b -> TypeMap d -> TypeMap ('(a, b) : d)
infixr 5 <|

-- | Add an element to the end of a list. <i>O(log n)</i>
snoc :: forall a d b. Last d ~ '(a, b) => TypeMap (Init d) -> b -> TypeMap d
infixl 5 `snoc`

-- | Synonym of <a>snoc</a>.
(|>) :: forall a d b. Last d ~ '(a, b) => TypeMap (Init d) -> b -> TypeMap d
infixl 5 |>

module Data.TypeMap.Static

-- | Index of type key <tt>a</tt> in association list <tt>d</tt>.
type family Index (a :: k) (d :: [(k, *)])

-- | Type associated with <tt>a</tt> in <tt>d</tt>. If the key <tt>a</tt>
--   occurs multiple times, the first one is used.
type family Lookup (a :: k) (d :: [(k, *)])

-- | Last element of a list.
type family Last (d :: [k])

-- | All elements except the last one.
type family Init (d :: [k])

module Data.TypeMap.Vector

-- | Vector-backed type-map.
data TypeVector d

-- | Empty vector.
empty :: TypeVector '[]

-- | Access an element indexed by type <tt>a</tt>. <i>O(1)</i>
--   
--   If <tt>a</tt> is associated to <tt>b</tt> in the type list <tt>d</tt>:
--   
--   <pre>
--   <a>index</a> @a (v :: <a>TypeVector</a> d) :: b
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let v = (0 :: Int) &lt;| True &lt;| "Hello" &lt;| empty :: TypeVector '[ '("a", Int), '("b", Bool), '("c", String)]
--   
--   &gt;&gt;&gt; index @"c" v
--   "Hello"
--   </pre>
index :: forall a d. KnownNat (Index a d) => TypeVector d -> Lookup a d

-- | Add an element to the beginning of a vector. <i>O(n)</i>
cons :: forall a d b. b -> TypeVector d -> TypeVector ('(a, b) : d)
infixr 5 `cons`

-- | Synonym of <a>cons</a>.
(<|) :: forall a d b. b -> TypeVector d -> TypeVector ('(a, b) : d)
infixr 5 <|

-- | Add an element to the end of a vector. <i>O(n)</i>
snoc :: forall a d b. Last d ~ '(a, b) => TypeVector (Init d) -> b -> TypeVector d
infixr 5 `snoc`

-- | Synonym of <a>snoc</a>.
(|>) :: forall a d b. Last d ~ '(a, b) => TypeVector (Init d) -> b -> TypeVector d
infixr 5 |>

-- | Convert from a vector to a list.
toList :: TypeVector d -> TypeList l