diff --git a/composition-extra.cabal b/composition-extra.cabal
--- a/composition-extra.cabal
+++ b/composition-extra.cabal
@@ -1,5 +1,5 @@
 name:                composition-extra
-version:             1.2.0
+version:             1.3.0
 synopsis:            Combinators for unorthodox structure composition
 
 license:             BSD3
@@ -13,14 +13,13 @@
 
 library
   hs-source-dirs:      src
-  exposed-modules:     Data.Functor.Syntax
-                       Data.Functor.Contravariant.Syntax
+  exposed-modules:     Data.Function.Syntax
                        Data.Function.Contravariant.Syntax
-                       Data.Function.Syntax
                        Data.Function.Apply
                        Data.Function.Flip
                        Data.Function.Slip
                        Data.Function.Twist
+                       Data.Functor.Syntax
                        Control.Monad.Syntax
                        Control.Monad.Syntax.Two
                        Control.Monad.Syntax.Three
diff --git a/src/Data/Function/Contravariant/Syntax.hs b/src/Data/Function/Contravariant/Syntax.hs
--- a/src/Data/Function/Contravariant/Syntax.hs
+++ b/src/Data/Function/Contravariant/Syntax.hs
@@ -5,58 +5,92 @@
      -> a -> c
 (-.) = flip (.)
 
+infixr 8 -.
+
 (-.:) :: (b -> c)
       -> (a -> c -> d)
       -> a -> b -> d
 (-.:) p q a b = q a $ p b
 
+infixr 8 -.:
+
 (-.*) = (-.:)
 
+infixr 8 -.*
+
 (-.:.) :: (c -> d)
        -> (a -> b -> d -> e)
        -> a -> b -> c -> e
 (-.:.) p q a b c = q a b $ p c
 
+infixr 8 -.:.
+
 (-.**) = (-.:.)
 
+infixr 8 -.**
+
 (-.::) :: (d -> e)
        -> (a -> b -> c -> e -> f)
        -> a -> b -> c -> d -> f
 (-.::) p q a b c d = q a b c $ p d
 
+infixr 8 -.::
+
 (-.***) = (-.::)
 
+infixr 8 -.***
+
 (-.::.) :: (e -> f)
         -> (a -> b -> c -> d -> f -> g)
         -> a -> b -> c -> d -> e -> g
 (-.::.) p q a b c d e = q a b c d $ p e
 
+infixr 8 -.::.
+
 (-.****) = (-.::.)
 
+infixr 8 -.****
+
 (-.:::) :: (f -> g)
         -> (a -> b -> c -> d -> e -> g -> h)
         -> a -> b -> c -> d -> e -> f -> h
 (-.:::) p q a b c d e f = q a b c d e $ p f
 
+infixr 8 -.:::
+
 (-.*****) = (-.:::)
 
+infixr 8 -.*****
+
 (-.:::.) :: (g -> h)
          -> (a -> b -> c -> d -> e -> f -> h -> i)
          -> a -> b -> c -> d -> e -> f -> g -> i
 (-.:::.) p q a b c d e f g = q a b c d e f $ p g
 
+infixr 8 -.:::.
+
 (-.******) = (-.:::.)
 
+infixr 8 -.******
+
 (-.::::) :: (h -> i)
          -> (a -> b -> c -> d -> e -> f -> g -> i -> j)
          -> a -> b -> c -> d -> e -> f -> g -> h -> j
 (-.::::) p q a b c d e f g h = q a b c d e f g $ p h
 
+infixr 8 -.::::
+
 (-.*******) = (-.::::)
 
+infixr 8 -.*******
+
 (-.::::.) :: (i -> j)
           -> (a -> b -> c -> d -> e -> f -> g -> h -> j -> k)
           -> a -> b -> c -> d -> e -> f -> g -> h -> i -> k
 (-.::::.) p q a b c d e f g h i = q a b c d e f g h $ p i
 
+infixr 8 -.::::.
+
 (-.********) = (-.::::.)
+
+infixr 8 -.********
diff --git a/src/Data/Function/Syntax.hs b/src/Data/Function/Syntax.hs
--- a/src/Data/Function/Syntax.hs
+++ b/src/Data/Function/Syntax.hs
@@ -1,8 +1,59 @@
 module Data.Function.Syntax
   ( module X
+  , (*.)
+  , (**.)
+  , (***.)
+  , (****.)
+  , (*****.)
+  , (******.)
+  , (*******.)
+  , (********.)
   ) where
 
+import Data.Composition as X
+import Data.Function.Contravariant.Syntax as X
 import Data.Function.Apply as X
 import Data.Function.Flip  as X
 import Data.Function.Slip  as X
 import Data.Function.Twist as X
+
+
+(*.) :: (a -> c -> d) -> (b -> c) -> a -> b -> d
+(*.) = flip (-.*)
+
+infixl 8 *.
+
+(**.) :: (a -> b -> d -> e) -> (c -> d) -> a -> b -> c -> e
+(**.) = flip (-.**)
+
+infixl 8 **.
+
+(***.) :: (a -> b -> c -> e -> f) -> (d -> e) -> a -> b -> c -> d -> f
+(***.) = flip (-.***)
+
+infixl 8 ***.
+
+(****.) :: (a -> b -> c -> d -> f -> g) -> (e -> f) -> a -> b -> c -> d -> e -> g
+(****.) = flip (-.****)
+
+infixl 8 ****.
+
+(*****.) :: (a -> b -> c -> d -> e -> g -> h) -> (f -> g) -> a -> b -> c -> d -> e -> f -> h
+(*****.) = flip (-.*****)
+
+infixl 8 *****.
+
+(******.) :: (a -> b -> c -> d -> e -> f -> h -> i) -> (g -> h) -> a -> b -> c -> d -> e -> f -> g -> i
+(******.) = flip (-.******)
+
+infixl 8 ******.
+
+(*******.) :: (a -> b -> c -> d -> e -> f -> g -> i -> j) -> (h -> i) -> a -> b -> c -> d -> e -> f -> g -> h -> j
+(*******.) = flip (-.*******)
+
+infixl 8 *******.
+
+(********.) :: (a -> b -> c -> d -> e -> f -> g -> h -> j -> k) -> (i -> j) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> k
+(********.) = flip (-.********)
+
+infixl 8 ********.
diff --git a/src/Data/Functor/Contravariant/Syntax.hs b/src/Data/Functor/Contravariant/Syntax.hs
deleted file mode 100644
--- a/src/Data/Functor/Contravariant/Syntax.hs
+++ /dev/null
@@ -1,43 +0,0 @@
-module Data.Functor.Contravariant.Syntax where
-
-import Data.Functor.Contravariant
-
-(<-$>) :: Contravariant f =>
-          (a -> b)
-       -> f b
-       -> f a
-(<-$>) = contramap
-
-infixr 8 <-$>
-
-(<-$$>) :: (Contravariant f0, Contravariant f1) =>
-          (a -> b)
-       -> f1 (f0 a)
-       -> f1 (f0 b)
-(<-$$>) = contramap . contramap
-
-infixr 8 <-$$>
-
-(<-$$$>) :: (Contravariant f0, Contravariant f1, Contravariant f2) =>
-          (a -> b)
-       -> f2 (f1 (f0 b))
-       -> f2 (f1 (f0 a))
-(<-$$$>) = contramap . contramap . contramap
-
-infixr 8 <-$$$>
-
-(<-$$$$>) :: (Contravariant f0, Contravariant f1, Contravariant f2, Contravariant f3) =>
-          (a -> b)
-       -> f3 (f2 (f1 (f0 a)))
-       -> f3 (f2 (f1 (f0 b)))
-(<-$$$$>) = contramap . contramap . contramap . contramap
-
-infixr 8 <-$$$$>
-
-(<-$$$$$>) :: (Contravariant f0, Contravariant f1, Contravariant f2, Contravariant f3, Contravariant f4) =>
-          (a -> b)
-       -> f4 (f3 (f2 (f1 (f0 b))))
-       -> f4 (f3 (f2 (f1 (f0 a))))
-(<-$$$$$>) = contramap . contramap . contramap . contramap . contramap
-
-infixr 8 <-$$$$$>
diff --git a/src/Data/Functor/Syntax.hs b/src/Data/Functor/Syntax.hs
--- a/src/Data/Functor/Syntax.hs
+++ b/src/Data/Functor/Syntax.hs
@@ -1,7 +1,6 @@
 module Data.Functor.Syntax where
 
-import Data.Composition
-import Data.Function.Apply
+import Data.Function.Syntax
 
 
 -- * Nested Mapping
@@ -40,115 +39,234 @@
 
 -- * Nested Application
 
-(<~$>) :: Functor f0 =>
+(<$~>) :: Functor f0 =>
           f0 (a -> b)
        -> a -> f0 b
-(<~$>) f x = fmap ($ x) f
+(<$~>) f x = fmap ($ x) f
 
-infixl 8 <~$>
+infixl 8 <$~>
 
-(<~~$>) :: Functor f0 =>
+(<~$>) :: Functor f0 =>
+          (a -> b -> c)
+       -> f0 b
+       -> f0 (a -> c)
+(<~$>) f = fmap (f -$)
+
+infixr 8 <~$>
+
+(<$~~>) :: Functor f0 =>
           f0 (a -> b -> c)
        -> b -> f0 (a -> c)
-(<~~$>) f x = fmap (-$ x) f
+(<$~~>) f x = fmap (-$ x) f
 
-infixl 8 <~~$>
+infixl 8 <$~~>
 
-(<~~~$>) :: Functor f0 =>
+(<~~$>) :: Functor f0 =>
+           (a -> b -> c -> d)
+        -> f0 c
+        -> f0 (a -> b -> d)
+(<~~$>) f = fmap (f --$)
+
+infixr 8 <~~$>
+
+(<$~~~>) :: Functor f0 =>
           f0 (a -> b -> c -> d)
        -> c -> f0 (a -> b -> d)
-(<~~~$>) f x = fmap (--$ x) f
+(<$~~~>) f x = fmap (--$ x) f
 
-infixl 8 <~~~$>
+infixl 8 <$~~~>
 
-(<~$$>) :: (Functor f0, Functor f1) =>
+(<~~~$>) :: Functor f0 =>
+            (a -> b -> c -> d -> e)
+         -> f0 d
+         -> f0 (a -> b -> c -> e)
+(<~~~$>) f = fmap (f ---$)
+
+infixr 8 <~~~$>
+
+(<$$~>) :: (Functor f0, Functor f1) =>
            f1 (f0 (a -> b))
         -> a -> f1 (f0 b)
-(<~$$>) f x = fmap (<~$> x) f
+(<$$~>) f x = fmap (<$~> x) f
 
-infixl 8 <~$$>
+infixl 8 <$$~>
 
-(<~~$$>) :: (Functor f0, Functor f1) =>
+(<~$$>) :: (Functor f0, Functor f1) =>
+           (a -> b -> c)
+        -> f1 (f0 b)
+        -> f1 (f0 (a -> c))
+(<~$$>) f = fmap (f <~$>)
+
+infixr 8 <~$$>
+
+(<$$~~>) :: (Functor f0, Functor f1) =>
             f1 (f0 (a -> b -> c))
          -> b -> f1 (f0 (a -> c))
-(<~~$$>) f x = fmap (<~~$> x) f
+(<$$~~>) f x = fmap (<$~~> x) f
 
-infixl 8 <~~$$>
+infixl 8 <$$~~>
 
-(<~~~$$>) :: (Functor f0, Functor f1) =>
+(<~~$$>) :: (Functor f0, Functor f1) =>
+            (a -> b -> c -> d)
+         -> f1 (f0 c)
+         -> f1 (f0 (a -> b -> d))
+(<~~$$>) f = fmap (f <~~$>)
+
+infixr 8 <~~$$>
+
+(<$$~~~>) :: (Functor f0, Functor f1) =>
              f1 (f0 (a -> b -> c -> d))
           -> c -> f1 (f0 (a -> b -> d))
-(<~~~$$>) f x = fmap (<~~~$> x) f
+(<$$~~~>) f x = fmap (<$~~~> x) f
 
-infixl 8 <~~~$$>
+infixl 8 <$$~~~>
 
+(<~~~$$>) :: (Functor f0, Functor f1) =>
+             (a -> b -> c -> d -> e)
+          -> f1 (f0 d)
+          -> f1 (f0 (a -> b -> c -> e))
+(<~~~$$>) f = fmap (f <~~~$>)
 
-(<~$$$>) :: (Functor f0, Functor f1, Functor f2) =>
+infixr 8 <~~~$$>
+
+
+(<$$$~>) :: (Functor f0, Functor f1, Functor f2) =>
             f2 (f1 (f0 (a -> b)))
          -> a -> f2 (f1 (f0 b))
-(<~$$$>) f x = fmap (<~$$> x) f
+(<$$$~>) f x = fmap (<$$~> x) f
 
-infixl 8 <~$$$>
+infixl 8 <$$$~>
 
-(<~~$$$>) :: (Functor f0, Functor f1, Functor f2) =>
+(<~$$$>) :: (Functor f0, Functor f1, Functor f2) =>
+            (a -> b -> c)
+         -> f2 (f1 (f0 b))
+         -> f2 (f1 (f0 (a -> c)))
+(<~$$$>) f = fmap (f <~$$>)
+
+infixr 8 <~$$$>
+
+(<$$$~~>) :: (Functor f0, Functor f1, Functor f2) =>
             f2 (f1 (f0 (a -> b -> c)))
          -> b -> f2 (f1 (f0 (a -> c)))
-(<~~$$$>) f x = fmap (<~~$$> x) f
+(<$$$~~>) f x = fmap (<$$~~> x) f
 
-infixl 8 <~~$$$>
+infixl 8 <$$$~~>
 
-(<~~~$$$>) :: (Functor f0, Functor f1, Functor f2) =>
+(<~~$$$>) :: (Functor f0, Functor f1, Functor f2) =>
+             (a -> b -> c -> d)
+          -> f2 (f1 (f0 c))
+          -> f2 (f1 (f0 (a -> b -> d)))
+(<~~$$$>) f = fmap (f <~~$$>)
+
+infixr 8 <~~$$$>
+
+(<$$$~~~>) :: (Functor f0, Functor f1, Functor f2) =>
              f2 (f1 (f0 (a -> b -> c -> d)))
           -> c -> f2 (f1 (f0 (a -> b -> d)))
-(<~~~$$$>) f x = fmap (<~~~$$> x) f
+(<$$$~~~>) f x = fmap (<$$~~~> x) f
 
-infixl 8 <~~~$$$>
+infixl 8 <$$$~~~>
 
+(<~~~$$$>) :: (Functor f0, Functor f1, Functor f2) =>
+              (a -> b -> c -> d -> e)
+           -> f2 (f1 (f0 d))
+           -> f2 (f1 (f0 (a -> b -> c -> e)))
+(<~~~$$$>) f = fmap (f <~~~$$>)
 
-(<~$$$$>) :: (Functor f0, Functor f1, Functor f2, Functor f3) =>
+infixr 8 <~~~$$$>
+
+
+(<$$$$~>) :: (Functor f0, Functor f1, Functor f2, Functor f3) =>
              f3 (f2 (f1 (f0 (a -> b))))
           -> a -> f3 (f2 (f1 (f0 b)))
-(<~$$$$>) f x = fmap (<~$$$> x) f
+(<$$$$~>) f x = fmap (<$$$~> x) f
 
-infixl 8 <~$$$$>
+infixl 8 <$$$$~>
 
-(<~~$$$$>) :: (Functor f0, Functor f1, Functor f2, Functor f3) =>
+(<~$$$$>) :: (Functor f0, Functor f1, Functor f2, Functor f3) =>
+             (a -> b -> c)
+          -> f3 (f2 (f1 (f0 b)))
+          -> f3 (f2 (f1 (f0 (a -> c))))
+(<~$$$$>) f = fmap (f <~$$$>)
+
+infixr 8 <~$$$$>
+
+(<$$$$~~>) :: (Functor f0, Functor f1, Functor f2, Functor f3) =>
             f3 (f2 (f1 (f0 (a -> b -> c))))
          -> b -> f3 (f2 (f1 (f0 (a -> c))))
-(<~~$$$$>) f x = fmap (<~~$$$> x) f
+(<$$$$~~>) f x = fmap (<$$$~~> x) f
 
-infixl 8 <~~$$$$>
+infixl 8 <$$$$~~>
 
-(<~~~$$$$>) :: (Functor f0, Functor f1, Functor f2, Functor f3) =>
+(<~~$$$$>) :: (Functor f0, Functor f1, Functor f2, Functor f3) =>
+              (a -> b -> c -> d)
+           -> f3 (f2 (f1 (f0 c)))
+           -> f3 (f2 (f1 (f0 (a -> b -> d))))
+(<~~$$$$>) f = fmap (f <~~$$$>)
+
+infixr 8 <~~$$$$>
+
+(<$$$$~~~>) :: (Functor f0, Functor f1, Functor f2, Functor f3) =>
              f3 (f2 (f1 (f0 (a -> b -> c -> d))))
           -> c -> f3 (f2 (f1 (f0 (a -> b -> d))))
-(<~~~$$$$>) f x = fmap (<~~~$$$> x) f
+(<$$$$~~~>) f x = fmap (<$$$~~~> x) f
 
-infixl 8 <~~~$$$$>
+infixl 8 <$$$$~~~>
 
+(<~~~$$$$>) :: (Functor f0, Functor f1, Functor f2, Functor f3) =>
+               (a -> b -> c -> d -> e)
+            -> f3 (f2 (f1 (f0 d)))
+            -> f3 (f2 (f1 (f0 (a -> b -> c -> e))))
+(<~~~$$$$>) f = fmap (f <~~~$$$>)
 
-(<~$$$$$>) :: (Functor f0, Functor f1, Functor f2, Functor f3, Functor f4) =>
+infixr 8 <~~~$$$$>
+
+
+(<$$$$$~>) :: (Functor f0, Functor f1, Functor f2, Functor f3, Functor f4) =>
              f4 (f3 (f2 (f1 (f0 (a -> b)))))
           -> a -> f4 (f3 (f2 (f1 (f0 b))))
-(<~$$$$$>) f x = fmap (<~$$$$> x) f
+(<$$$$$~>) f x = fmap (<$$$$~> x) f
 
-infixl 8 <~$$$$$>
+infixl 8 <$$$$$~>
 
-(<~~$$$$$>) :: (Functor f0, Functor f1, Functor f2, Functor f3, Functor f4) =>
+(<~$$$$$>) :: (Functor f0, Functor f1, Functor f2, Functor f3, Functor f4) =>
+              (a -> b -> c)
+           -> f4 (f3 (f2 (f1 (f0 b))))
+           -> f4 (f3 (f2 (f1 (f0 (a -> c)))))
+(<~$$$$$>) f = fmap (f <~$$$$>)
+
+infixr 8 <~$$$$$>
+
+(<$$$$$~~>) :: (Functor f0, Functor f1, Functor f2, Functor f3, Functor f4) =>
             f4 (f3 (f2 (f1 (f0 (a -> b -> c)))))
          -> b -> f4 (f3 (f2 (f1 (f0 (a -> c)))))
-(<~~$$$$$>) f x = fmap (<~~$$$$> x) f
+(<$$$$$~~>) f x = fmap (<$$$$~~> x) f
 
-infixl 8 <~~$$$$$>
+infixl 8 <$$$$$~~>
 
-(<~~~$$$$$>) :: (Functor f0, Functor f1, Functor f2, Functor f3, Functor f4) =>
-             f4 (f3 (f2 (f1 (f0 (a -> b -> c -> d)))))
-          -> c -> f4 (f3 (f2 (f1 (f0 (a -> b -> d)))))
-(<~~~$$$$$>) f x = fmap (<~~~$$$$> x) f
+(<~~$$$$$>) :: (Functor f0, Functor f1, Functor f2, Functor f3, Functor f4) =>
+               (a -> b -> c -> d)
+            -> f4 (f3 (f2 (f1 (f0 c))))
+            -> f4 (f3 (f2 (f1 (f0 (a -> b -> d)))))
+(<~~$$$$$>) f = fmap (f <~~$$$$>)
 
-infixl 8 <~~~$$$$$>
+infixr 8 <~~$$$$$>
 
+(<$$$$$~~~>) :: (Functor f0, Functor f1, Functor f2, Functor f3, Functor f4) =>
+                f4 (f3 (f2 (f1 (f0 (a -> b -> c -> d)))))
+             -> c -> f4 (f3 (f2 (f1 (f0 (a -> b -> d)))))
+(<$$$$$~~~>) f x = fmap (<$$$$~~~> x) f
 
+infixl 8 <$$$$$~~~>
+
+(<~~~$$$$$>) :: (Functor f0, Functor f1, Functor f2, Functor f3, Functor f4) =>
+                (a -> b -> c -> d -> e)
+             -> f4 (f3 (f2 (f1 (f0 d))))
+             -> f4 (f3 (f2 (f1 (f0 (a -> b -> c -> e)))))
+(<~~~$$$$$>) f = fmap (f <~~~$$$$>)
+
+infixr 8 <~~~$$$$$>
+
 -- * Nested Compositon
 
 (<.$>) :: Functor f0 =>
@@ -166,6 +284,15 @@
 f <.*$> g = fmap (f .*) g
 
 infixr 8 <.*$>
+
+-- TODO: Expand
+(<*.$>) :: Functor f0 =>
+           (a -> c -> d)
+        -> f0 (b -> c)
+        -> f0 (a -> b -> d)
+f <*.$> g = fmap (f *.) g
+
+infixr 8 <*.$>
 
 (<.**$>) :: Functor f0 =>
            (d -> e)