diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -7,6 +7,9 @@
 
 # Changelog
 
+* 0.4.0.0
+  - Added PNullary and PUnary injective type families.
+
 * 0.3.0.0
   - PMonoid is now a class with a single instance (courtesy of georgew).
   - added fixities for backtick versions of pmappend, pappend, papply and pbind
diff --git a/parameterized.cabal b/parameterized.cabal
--- a/parameterized.cabal
+++ b/parameterized.cabal
@@ -1,6 +1,6 @@
 name:                parameterized
-version:             0.3.0.0
-synopsis:            Extensible records and polymorphic variants.
+version:             0.4.0.0
+synopsis:            Parameterized/indexed monoids and monads using only a single parameter type variable.
 description:         Parameterized/indexed monoids and monads using only a single parameter type variable.
 
 homepage:            https://github.com/louispan/parameterized#readme
diff --git a/src/Parameterized/Control/Applicative.hs b/src/Parameterized/Control/Applicative.hs
--- a/src/Parameterized/Control/Applicative.hs
+++ b/src/Parameterized/Control/Applicative.hs
@@ -3,9 +3,11 @@
 {-# LANGUAGE KindSignatures #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TypeFamilyDependencies #-}
 
 module Parameterized.Control.Applicative
-    ( PPointed(..)
+    ( PUnary
+    , PPointed(..)
     , PApplicative(..)
     , (&<*>)
     , (&*>)
@@ -20,6 +22,8 @@
 
 import Data.Kind
 
+type family PUnary (m :: k -> Type -> Type) (t :: k) = (r :: Type -> Type) | r -> m t
+
 -- | Parameterized version of 'pure' in 'Applicative'
 -- An instance of this should create a parameterized unary type
 -- where the parameter is an identity in respect to 'papply'
@@ -29,38 +33,38 @@
 -- Hint: use @ppure \@_ \@_ @id@ to specify the id type to avoid ambiguity.
 class PPointed (m :: k -> Type -> Type) (id :: k) where
     -- | lift a value.
-    ppure :: a -> m id a
+    ppure :: a -> PUnary m id a
 
 -- | Parameterized version of 'ap' in 'Applicative'
 -- NB. 'PPointed' cannot be made a superclass because type variable @id@ is not in scope.
-class (Functor (m t), Functor (m u), Functor (m v)) =>
+class (Functor (PUnary m t), Functor (PUnary m u), Functor (PUnary m v)) =>
       PApplicative (m :: k -> Type -> Type) (t :: k) (u :: k) (v :: k) | t u -> v where
     -- | Sequential application.
-    papply :: m t (a -> b) -> m u a -> m v b
+    papply :: PUnary m t (a -> b) -> PUnary m u a -> PUnary m v b
 
 
 -- | Sequential application.
-(&<*>) :: (PApplicative m t u v) => m t (a -> b) -> m u a -> m v b
+(&<*>) :: (PApplicative m t u v) => PUnary m t (a -> b) -> PUnary m u a -> PUnary m v b
 (&<*>) = papply
 infixl 4 &<*>
 infixl 4 `papply`
 
 -- | Sequence actions, discarding the value of the first argument.
-(&*>) :: (PApplicative m t u v) => m t a -> m u b -> m v b
+(&*>) :: (PApplicative m t u v) => PUnary m t a -> PUnary m u b -> PUnary m v b
 a1 &*> a2 = (id <$ a1) &<*> a2
 infixl 4 &*>
 
 -- | Sequence actions, discarding the value of the second argument.
-(&<*) :: (PApplicative m t u v) => m t a -> m u b -> m v a
+(&<*) :: (PApplicative m t u v) => PUnary m t a -> PUnary m u b -> PUnary m v a
 (&<*) = pliftA2 const
 infixl 4 &<*
 
 -- | Lift a function to actions.
-pliftA :: (Functor (m t)) => (a -> b) -> m t a -> m t b
+pliftA :: (Functor (PUnary m t)) => (a -> b) -> PUnary m t a -> PUnary m t b
 pliftA f x = f <$> x
 
 -- | Lift a binary function to actions.
-pliftA2 :: (PApplicative m t u v) => (a -> b -> c) -> m t a -> m u b -> m v c
+pliftA2 :: (PApplicative m t u v) => (a -> b -> c) -> PUnary m t a -> PUnary m u b -> PUnary m v c
 pliftA2 f x y = (f <$> x) `papply` y
 
 -- | Lift a ternary function to actions.
@@ -68,7 +72,7 @@
     :: ( PApplicative m t u v
        , PApplicative m v w x
        )
-    => (a -> b -> c -> d) -> m t a -> m u b -> m w c -> m x d
+    => (a -> b -> c -> d) -> PUnary m t a -> PUnary m u b -> PUnary m w c -> PUnary m x d
 pliftA3 f a b c = pliftA2 f a b &<*> c
 
 -- | Parameterized version of empty in 'Alternative'.
@@ -76,7 +80,7 @@
 -- where the parameter is an identity in respect to 'pappend'
 class PEmpty (m :: k -> Type -> Type) (id :: k) | m -> id where
     -- | The identity of '&<|>'
-    pempty :: m id a
+    pempty :: PUnary m id a
 
 -- | Parameterized version of 'Alternative'
 -- NB. 'PEmpty' cannot be made a superclass because type variable @id@ will be ambiguous.
@@ -84,9 +88,9 @@
 -- Some things can be made instances of 'PAlternative' but not 'PApplicative'.
 class PAlternative (m :: k -> Type -> Type) (t :: k) (u :: k) (v :: k) | t u -> v where
     -- | An associative binary operation
-    pappend :: m t a -> m u a -> m v a
+    pappend :: PUnary m t a -> PUnary m u a -> PUnary m v a
 
-(&<|>) :: (PAlternative m t u v) => m t a -> m u a -> m v a
+(&<|>) :: (PAlternative m t u v) => PUnary m t a -> PUnary m u a -> PUnary m v a
 (&<|>) = pappend
 infixl 3 &<|>
 infixl 3 `pappend`
diff --git a/src/Parameterized/Control/Monad.hs b/src/Parameterized/Control/Monad.hs
--- a/src/Parameterized/Control/Monad.hs
+++ b/src/Parameterized/Control/Monad.hs
@@ -20,30 +20,30 @@
 -- | Parameterized version of Monad.
 class PApplicative m t u v => PMonad (m :: k -> Type -> Type) (t :: k) (u :: k) (v :: k) where
     -- | Sequentially compose two actions, passing any value produced by the first as an argument to the second.
-    pbind :: m t a -> (a -> m u b) -> m v b
+    pbind :: PUnary m t a -> (a -> PUnary m u b) -> PUnary m v b
 
 -- | Sequentially compose two actions, passing any value produced by the first as an argument to the second.
-(&>>=) :: PMonad m t u v => m t a -> (a -> m u b) -> m v b
+(&>>=) :: PMonad m t u v => PUnary m t a -> (a -> PUnary m u b) -> PUnary m v b
 (&>>=) = pbind
 infixl 1 &>>=
 infixl 1 `pbind`
 
-(&>>) :: PMonad m t u v => m t a -> m u b -> m v b
+(&>>) :: PMonad m t u v => PUnary m t a -> PUnary m u b -> PUnary m v b
 m &>> k = m &>>= \_ -> k
 infixl 1 &>>
 
 -- | Same as '&>>=', but with the arguments interchanged.
-(&=<<) :: PMonad m t u v => (a -> m u b) -> m t a -> m v b
+(&=<<) :: PMonad m t u v => (a -> PUnary m u b) -> PUnary m t a -> PUnary m v b
 f &=<< x = x &>>= f
 infixr 1 &=<<
 
 -- | Left-to-right Kleisli composition of monads.
-(&>=>) :: (PMonad m t u v) => (a -> m t b) -> (b -> m u c) -> (a -> m v c)
+(&>=>) :: (PMonad m t u v) => (a -> PUnary m t b) -> (b -> PUnary m u c) -> (a -> PUnary m v c)
 f &>=> g = \x -> f x &>>= g
 infixr 1 &>=>
 
 -- | Right-to-left Kleisli composition of monads. @('>=>')@, with the arguments flipped.
-(&<=<) :: (PMonad m t u v) => (b -> m u c) -> (a -> m t b) -> (a -> m v c)
+(&<=<) :: (PMonad m t u v) => (b -> PUnary m u c) -> (a -> PUnary m t b) -> (a -> PUnary m v c)
 (&<=<) = flip (&>=>)
 infixr 1 &<=<
 
diff --git a/src/Parameterized/Control/Monad/Trans/Reader.hs b/src/Parameterized/Control/Monad/Trans/Reader.hs
--- a/src/Parameterized/Control/Monad/Trans/Reader.hs
+++ b/src/Parameterized/Control/Monad/Trans/Reader.hs
@@ -39,6 +39,8 @@
                , MonadIO
                )
 
+type instance PUnary (OverlappingWhichReader m) r = OverlappingWhichReader m r
+
 instance Applicative m => PPointed (OverlappingWhichReader m) (Which '[]) where
     ppure = OverlappingWhichReader . pure
 
@@ -81,6 +83,8 @@
                , MonadIO
                )
 
+type instance PUnary (DistinctWhichReader m) r = DistinctWhichReader m r
+
 instance Applicative m => PPointed (DistinctWhichReader m) (Which '[]) where
     ppure = DistinctWhichReader . pure
 
@@ -117,6 +121,8 @@
                , MonadIO
                )
 
+type instance PUnary (ManyReader m) r = ManyReader m r
+
 instance Applicative m => PPointed (ManyReader m) (Many '[]) where
     ppure = ManyReader . pure
 
@@ -133,8 +139,7 @@
     papply (ManyReader (ReaderT f)) (ManyReader (ReaderT g)) =
         ManyReader . ReaderT $ \c -> f (select c) <*> g (select c)
 
-instance ( Functor (ManyReader m (Many c))
-         , Alternative m
+instance ( Alternative m
          , Select a c
          , Select b c
          , c ~ AppendUnique a b
diff --git a/src/Parameterized/Control/Monad/Trans/State/Strict.hs b/src/Parameterized/Control/Monad/Trans/State/Strict.hs
--- a/src/Parameterized/Control/Monad/Trans/State/Strict.hs
+++ b/src/Parameterized/Control/Monad/Trans/State/Strict.hs
@@ -38,6 +38,8 @@
                , MonadIO
                )
 
+type instance PUnary (ManyState m) s = ManyState m s
+
 instance Monad m => PPointed (ManyState m) (Many '[]) where
     ppure = ManyState . pure
 
@@ -111,6 +113,8 @@
 -- as it avoids ambiguous type variable @st@
 changingState :: (s -> m (a, t)) -> ChangingState m (s, t) a
 changingState = ChangingState
+
+type instance PUnary (ChangingState m) st = ChangingState m st
 
 instance Functor m => Functor (ChangingState m st) where
     fmap f m = ChangingState $ \s ->
diff --git a/src/Parameterized/Data/Monoid.hs b/src/Parameterized/Data/Monoid.hs
--- a/src/Parameterized/Data/Monoid.hs
+++ b/src/Parameterized/Data/Monoid.hs
@@ -17,7 +17,7 @@
 
 -- | Parameterized version of mempty in Monoid.
 class PMEmpty (n :: k -> Type) (id :: k) | n -> id where
-    pmempty :: n id
+    pmempty :: PNullary n id
 
 -- | Parameterized version of Monoid.
 class (PSemigroup n t u v, PMEmpty n id) => PMonoid n id t u v
diff --git a/src/Parameterized/Data/Semigroup.hs b/src/Parameterized/Data/Semigroup.hs
--- a/src/Parameterized/Data/Semigroup.hs
+++ b/src/Parameterized/Data/Semigroup.hs
@@ -2,11 +2,14 @@
 {-# LANGUAGE KindSignatures #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TypeFamilyDependencies #-}
 
 module Parameterized.Data.Semigroup where
 
 import Data.Kind
 
+type family PNullary (n :: k -> Type) (t :: k) = (r :: Type) | r -> n t
+
 -- | Parameterized version of (<>) in Semigroup
 -- If used in conjunction with 'Parameterized.Data.Empty', ie as a parameterized Monoid,
 -- then the instance should follow the following laws:
@@ -14,9 +17,9 @@
 --  * @x `pmappend'` pempty' = x@
 --  * @x `pmappend'` (y `pmappend'` z) = (x `pmappend'` y) `pmappend'` z@
 class PSemigroup (n :: k -> Type) (t :: k) (u :: k) (v :: k) | t u -> v where
-    pmappend :: n t -> n u -> n v
+    pmappend :: PNullary n t -> PNullary n u -> PNullary n v
 
-(&<>) :: (PSemigroup n t u v) => n t -> n u -> n v
+(&<>) :: (PSemigroup n t u v) => PNullary n t -> PNullary n u -> PNullary n v
 (&<>) = pmappend
 infixr 6 &<>
 infixr 6 `pmappend`