diff --git a/Changelog.md b/Changelog.md
new file mode 100644
--- /dev/null
+++ b/Changelog.md
@@ -0,0 +1,9 @@
+# Changelog
+
+## Version 0.4
+
+ * add a proxy to most `runLog` functions to not have to supply the full
+   specialized type signature. Use something like `data Proxy a = Proxy` or
+   the one from `tagged`.
+
+ * remove `ShowLog` typeclass in favor of `ToLogString` from `fast-logger`.
diff --git a/examples/IOLogger.hs b/examples/IOLogger.hs
new file mode 100644
--- /dev/null
+++ b/examples/IOLogger.hs
@@ -0,0 +1,17 @@
+{-# LANGUAGE OverloadedStrings #-}
+module Main (main) where
+
+import Control.Eff
+import Control.Eff.Lift
+import Control.Eff.Log
+import System.Log.FastLogger
+
+data Proxy a = Proxy
+
+main :: IO ()
+main = do
+    loggerSet <- newStderrLoggerSet defaultBufSize
+    pushLogStr loggerSet "logging from outer space^WIO\n"
+    runLift $ runLogWithLoggerSet loggerSet (Proxy :: Proxy String) $
+        logE ("logging from inner Eff" :: String)
+    flushLogStr loggerSet
diff --git a/log-effect.cabal b/log-effect.cabal
--- a/log-effect.cabal
+++ b/log-effect.cabal
@@ -2,7 +2,7 @@
 -- documentation, see http://haskell.org/cabal/users-guide/
 
 name:                log-effect
-version:             0.3.0.2
+version:             0.4.0.0
 synopsis:            An extensible log effect using extensible-effects
 description:         Any help (especially documentation) is very welcome,
 homepage:            https://github.com/ibotty/log-effect
@@ -13,7 +13,8 @@
 -- copyright:           
 category:            Control, Effect, Logging
 build-type:          Simple
--- extra-source-files:  
+extra-source-files:    Changelog.md
+                     , examples/IOLogger.hs
 cabal-version:       >=1.10
 
 library
@@ -24,7 +25,7 @@
   build-depends:       base >=4.6 && <4.8
                      , bytestring >=0.10.2 && <0.11
                      , extensible-effects ==1.4.* || ==1.7.*
-                     , fast-logger >=2.1 && <2.2
+                     , fast-logger >=2.1.4 && <2.2
                      , time >=1.4 && <1.5
   hs-source-dirs:      src
   default-language:    Haskell2010
diff --git a/src/Control/Eff/Log.hs b/src/Control/Eff/Log.hs
--- a/src/Control/Eff/Log.hs
+++ b/src/Control/Eff/Log.hs
@@ -1,30 +1,34 @@
-{-# LANGUAGE DeriveFunctor #-}
-{-# LANGUAGE DeriveDataTypeable #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE DeriveDataTypeable    #-}
+{-# LANGUAGE DeriveFunctor         #-}
+{-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE RankNTypes #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeOperators #-}
-{-# LANGUAGE UndecidableInstances #-}
+{-# LANGUAGE OverloadedStrings     #-}
+{-# LANGUAGE RankNTypes            #-}
+{-# LANGUAGE TypeOperators         #-}
 module Control.Eff.Log
   ( Log(Log, logLine)
-  , ShowLog(showLog)
   , logE
   , filterLog
+  , filterLog'
   , runLogPure
-  , runLogStdErr
+  , runLogStdout
+  , runLogStderr
   , runLogFile
+  , runLogWithLoggerSet
   , runLog
   ) where
 
-import Control.Applicative ((<$>))
-import Control.Eff ( Eff, Member, SetMember, VE(..), (:>)
-                   , admin, handleRelay, inj, interpose, send)
-import Control.Eff.Lift (Lift, lift)
-import Data.Typeable (Typeable, Typeable1)
-import System.IO (stderr)
-import System.Log.FastLogger (LoggerSet, LogStr, defaultBufSize, fromLogStr, newLoggerSet, pushLogStr, toLogStr)
+import Control.Applicative   ((<$>), (<*))
+import Control.Eff           ((:>), Eff, Member, SetMember, VE (..), admin,
+                              handleRelay, inj, interpose, send)
+import Control.Eff.Lift      (Lift, lift)
+import Data.Monoid           ((<>))
+import Data.Typeable         (Typeable, Typeable1)
+import System.Log.FastLogger (LogStr, LoggerSet, ToLogStr, defaultBufSize,
+                              flushLogStr, fromLogStr, newFileLoggerSet,
+                              newStderrLoggerSet, newStdoutLoggerSet,
+                              pushLogStr, toLogStr)
+
 import qualified Data.ByteString.Char8 as B8
 
 data Log a v = Log
@@ -32,12 +36,6 @@
   , logNext :: v
   } deriving (Typeable, Functor)
 
-class ShowLog l where
-    showLog :: l -> LogStr
-
-instance ShowLog String where
-    showLog = toLogStr
-
 -- | a monadic action that does the real logging
 type Logger m l = forall v. Log l v -> m ()
 
@@ -61,6 +59,10 @@
         go (E req) = handleRelay req go performLog
         performLog l = lift (logger l) >> go (logNext l)
 
+-- | Filter Log entries with a predicate.
+--
+-- Note that, most of the time an explicit type signature for the predicate
+-- will be required.
 filterLog :: (Typeable l, Member (Log l) r)
   => (l -> Bool) -> Eff r a -> Eff r a
 filterLog f = go . admin
@@ -68,24 +70,55 @@
         go (E req) = interpose req go filter'
           where filter' (Log l v) = if f l then send (<$> req) >>= go
                                            else go v
-runLogStdErr :: (Typeable l, ShowLog l, SetMember Lift (Lift IO) r)
-  => Eff (Log l :> r) a -> Eff r a
-runLogStdErr = runLog stdErrLogger
 
-stdErrLogger :: ShowLog l => Logger IO l
-stdErrLogger = B8.hPutStrLn stderr . fromLogStr . showLog . logLine
+-- | Filter Log entries with a predicate and a proxy.
+--
+-- This is the same as 'filterLog' but with a "proxy l" for type inference.
+filterLog' :: (Typeable l, Member (Log l) r)
+  => (l -> Bool) -> proxy l -> Eff r a -> Eff r a
+filterLog' predicate _ = filterLog predicate
 
+-- | Log to stdout.
+runLogStdout :: (Typeable l, ToLogStr l, SetMember Lift (Lift IO) r)
+  => proxy l -> Eff (Log l :> r) a -> Eff r a
+runLogStdout proxy eff = do
+    s <- lift $ newStdoutLoggerSet defaultBufSize
+    runLogWithLoggerSet s proxy eff <* lift (flushLogStr s)
+
+-- | Log to stderr.
+runLogStderr :: (Typeable l, ToLogStr l, SetMember Lift (Lift IO) r)
+  => proxy l -> Eff (Log l :> r) a -> Eff r a
+runLogStderr proxy eff = do
+    s <- lift $ newStderrLoggerSet defaultBufSize
+    runLogWithLoggerSet s proxy eff <* lift (flushLogStr s)
+
 -- | Log to file.
-runLogFile :: (Typeable l, ShowLog l, SetMember Lift (Lift IO) r)
-  => FilePath -> Eff (Log l :> r) a -> Eff r a
-runLogFile f eff = do
-    s <- lift (newLoggerSet defaultBufSize (Just f))
-    runLogWithLoggerSet s eff
+runLogFile :: (Typeable l, ToLogStr l, SetMember Lift (Lift IO) r)
+  => FilePath -> proxy l -> Eff (Log l :> r) a -> Eff r a
+runLogFile f proxy eff = do
+    s <- lift $ newFileLoggerSet defaultBufSize f
+    runLogWithLoggerSet s proxy eff <* lift (flushLogStr s)
 
 -- | Log to a file using a 'LoggerSet'.
-runLogWithLoggerSet :: (Typeable l, ShowLog l, SetMember Lift (Lift IO) r)
-  => LoggerSet -> Eff (Log l :> r) a -> Eff r a
-runLogWithLoggerSet s = runLog (fileLogger s)
+--
+-- Note, that you will still have to call 'flushLogStr' on the 'LoggerSet'
+-- at one point.
+--
+-- With that function you can combine a logger in a surrounding IO action
+-- with a logger in the 'Eff' effect.
+--
+-- >data Proxy a = Proxy
+-- >
+-- > main :: IO ()
+-- > main = do
+-- >     loggerSet <- newStderrLoggerSet defaultBufSize
+-- >     pushLogStr loggerSet "logging from outer space^WIO\n"
+-- >     runLift $ runLogWithLoggerSet loggerSet (Proxy :: Proxy String) $
+-- >         logE ("logging from within Eff" :: String)
+-- >     flushLogStr loggerSet
+runLogWithLoggerSet :: (Typeable l, ToLogStr l, SetMember Lift (Lift IO) r)
+  => LoggerSet -> proxy l -> Eff (Log l :> r) a -> Eff r a
+runLogWithLoggerSet s _ = runLog (loggerSetLogger s)
 
-fileLogger :: ShowLog l => LoggerSet -> Logger IO l
-fileLogger loggerSet = pushLogStr loggerSet . showLog . logLine
+loggerSetLogger :: ToLogStr l => LoggerSet -> Logger IO l
+loggerSetLogger loggerSet = pushLogStr loggerSet . (<> "\n") . toLogStr . logLine
diff --git a/src/Control/Eff/Log/Simple.hs b/src/Control/Eff/Log/Simple.hs
--- a/src/Control/Eff/Log/Simple.hs
+++ b/src/Control/Eff/Log/Simple.hs
@@ -1,9 +1,10 @@
-{-# LANGUAGE DeriveDataTypeable #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE RankNTypes #-}
-{-# LANGUAGE TypeOperators #-}
-{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE DeriveDataTypeable    #-}
+{-# LANGUAGE FlexibleContexts      #-}
+{-# LANGUAGE FlexibleInstances     #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE OverloadedStrings     #-}
+{-# LANGUAGE RankNTypes            #-}
+{-# LANGUAGE TypeOperators         #-}
 module Control.Eff.Log.Simple
   ( SimpleLog
   , Severity(..)
@@ -18,16 +19,32 @@
   , panic
   ) where
 
-import Prelude hiding (error)
-import Control.Eff (Eff, Member)
+import Control.Eff           (Eff, Member)
 import Control.Eff.Log
-import Data.Monoid ((<>))
-import Data.Typeable (Typeable)
-import System.Log.FastLogger (toLogStr)
+import Data.Monoid           ((<>))
+import Data.Typeable         (Typeable)
+import Prelude               hiding (error)
+import System.Log.FastLogger (ToLogStr, toLogStr)
 
-data Severity = DEBUG | INFO | NOTICE | WARNING | ERROR | CRITICAL | ALERT | PANIC
+data Severity =
+    DEBUG | INFO | NOTICE | WARNING | ERROR | CRITICAL | ALERT | PANIC
   deriving (Bounded, Enum, Eq, Ord, Read, Show, Typeable)
 
+type SimpleLog a = Log (Severity, a)
+
+instance ToLogStr Severity where
+    toLogStr DEBUG    = "DEBUG"
+    toLogStr INFO     = "INFO"
+    toLogStr NOTICE   = "NOTICE"
+    toLogStr WARNING  = "WARNING"
+    toLogStr ERROR    = "ERROR"
+    toLogStr CRITICAL = "CRITICAL"
+    toLogStr ALERT    = "ALERT"
+    toLogStr PANIC    = "PANIC"
+
+instance ToLogStr a => ToLogStr (Severity, a) where
+    toLogStr (sev, line) = "[" <> toLogStr sev <> "] " <> toLogStr line <> "\n"
+
 logTo :: (Typeable l, Member (Log (Severity, l)) r)
   => Severity -> l -> Eff r ()
 logTo sev line = logE (sev, line)
@@ -55,8 +72,3 @@
 
 panic :: (Typeable l, Member (Log (Severity, l)) r) => l -> Eff r ()
 panic = logTo PANIC
-
-type SimpleLog a = Log (Severity, a)
-
-instance ShowLog a => ShowLog (Severity, a) where
-    showLog (sev, line) = "[" <> toLogStr (show sev) <> "] " <> showLog line