diff --git a/ChannelT.cabal b/ChannelT.cabal
--- a/ChannelT.cabal
+++ b/ChannelT.cabal
@@ -1,5 +1,5 @@
 name:                ChannelT
-version:             0.0.0.4
+version:             0.0.0.5
 synopsis:            Generalized stream processors
 description:         A mutual generalization of <https://hackage.haskell.org/package/pipes pipes> and <https://hackage.haskell.org/package/machines machines>; a library for exploring a particular corner of the design space of streaming IO (and other related tasks) in Haskell.
 license:             BSD3
@@ -7,7 +7,7 @@
 author:              Alexander Altman
 maintainer:          alexanderaltman@me.com
 homepage:            https://github.com/pthariensflame/ChannelT
-copyright:           Copyright (c) 2015-2017, Alexander Altman
+copyright:           Copyright (c) 2015-2018, Alexander Altman
 category:            Control, Enumerator, Iteratee, Pipes, Proxies
 build-type:          Simple
 cabal-version:       >= 1.24
@@ -24,6 +24,6 @@
   -- other-modules:
   build-depends:       base >= 4.8.2.0 && < 5
                      , mtl >= 2.2.1 && < 2.3
-                     , free >= 4.12.4 && < 4.13
+                     , free >= 4.12.4 && < 6
                      , transformers-base >= 0.4.4 && < 0.5
                      , mmorph >= 1.0.5 && < 1.2
diff --git a/src/Control/Monad/Channel.hs b/src/Control/Monad/Channel.hs
--- a/src/Control/Monad/Channel.hs
+++ b/src/Control/Monad/Channel.hs
@@ -1,7 +1,9 @@
 {-# LANGUAGE Trustworthy #-}
-module Control.Monad.Channel (
-  Channel,
-  ChannelT,
-  MonadChannel(..),
-) where
-import Control.Monad.Channel.Internal
+
+module Control.Monad.Channel
+  ( Channel
+  , ChannelT
+  , MonadChannel(..)
+  ) where
+
+import           Control.Monad.Channel.Internal
diff --git a/src/Control/Monad/Channel/Internal.hs b/src/Control/Monad/Channel/Internal.hs
--- a/src/Control/Monad/Channel/Internal.hs
+++ b/src/Control/Monad/Channel/Internal.hs
@@ -1,38 +1,68 @@
-{-# LANGUAGE FunctionalDependencies, PolyKinds, FlexibleContexts #-}
-{-# LANGUAGE ExistentialQuantification, FlexibleInstances, UndecidableInstances #-}
-{-# LANGUAGE StandaloneDeriving, GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE AutoDeriveTypeable, DeriveFunctor, DeriveGeneric #-}
-module Control.Monad.Channel.Internal (ChannelT(..), Channel, MonadChannel(..), ChannelF(..)) where
-import Control.Monad.Trans
-import Control.Monad.Identity
-import Control.Monad.Base
-import Control.Monad.Morph
-import Control.Monad.Trans.Free
-import GHC.Generics
+{-# LANGUAGE AutoDeriveTypeable         #-}
+{-# LANGUAGE DeriveFunctor              #-}
+{-# LANGUAGE DeriveGeneric              #-}
+{-# LANGUAGE ExistentialQuantification  #-}
+{-# LANGUAGE FlexibleContexts           #-}
+{-# LANGUAGE FlexibleInstances          #-}
+{-# LANGUAGE FunctionalDependencies     #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE MultiParamTypeClasses      #-}
+{-# LANGUAGE PolyKinds                  #-}
+{-# LANGUAGE StandaloneDeriving         #-}
+{-# LANGUAGE UndecidableInstances       #-}
 
+module Control.Monad.Channel.Internal
+  ( ChannelT(..)
+  , Channel
+  , MonadChannel(..)
+  , ChannelF(..)
+  ) where
+
+import           Control.Monad.Base
+import           Control.Monad.Identity
+import           Control.Monad.Morph
+import           Control.Monad.Trans
+import           Control.Monad.Trans.Free
+import           GHC.Generics
+
 instance (MonadBase b m, Functor f) => MonadBase b (FreeT f m) where
   liftBase = liftBaseDefault
+
 instance Functor f => MFunctor (FreeT f) where
   hoist = hoistFreeT
+
 deriving instance Generic (FreeT f m a)
 
-newtype ChannelT sel m a = ChannelT { unChannelT :: FreeT (ChannelF sel) m a }
-  deriving (Functor, Applicative, Monad, MonadTrans, MonadFree (ChannelF sel), Generic1, Generic)
+newtype ChannelT sel m a = ChannelT
+  { unChannelT :: FreeT (ChannelF sel) m a
+  } deriving ( Functor
+             , Applicative
+             , Monad
+             , MonadTrans
+             , MonadFree (ChannelF sel)
+             , Generic1
+             , Generic
+             )
+
 deriving instance MonadBase b m => MonadBase b (ChannelT sel m)
 
-data ChannelF (sel :: * -> * -> *) (x :: *) =
-  forall (i :: *) (o :: *). SyncChannel {
-    selectorF :: sel i o,
-    outputF :: o,
-    inputF :: i -> x
+data ChannelF (sel :: * -> * -> *) (x :: *) = forall (o :: *) (i :: *). SyncChannel
+  { selectorF :: sel i o
+  , outputF   :: o
+  , inputF    :: i -> x
   }
+
 deriving instance Functor (ChannelF sel)
 
-class Monad m => MonadChannel (sel :: * -> * -> *) (m :: * -> *) | m -> sel where
+class Monad m =>
+      MonadChannel (sel :: * -> * -> *) (m :: * -> *)
+  | m -> sel
+  where
   syncOn :: sel i o -> o -> m i
 
 instance Monad m => MonadChannel sel (ChannelT sel m) where
-  syncOn s o = ChannelT . FreeT . return . Free . SyncChannel s o $ FreeT . return . Pure
+  syncOn s o =
+    ChannelT . FreeT . return . Free . SyncChannel s o $ FreeT . return . Pure
 
 -- NB: Don't use GeneralizedNewtypeDeriving to create this instance, as it will
 -- trigger GHC Trac #11837 on GHC 8.0.1 and older.