diff --git a/Data/String/Conversions.hs b/Data/String/Conversions.hs
--- a/Data/String/Conversions.hs
+++ b/Data/String/Conversions.hs
@@ -38,7 +38,9 @@
 
 import Data.Monoid
 
+#if !MIN_VERSION_base(4,8,0)
 import Control.Applicative
+#endif
 
 -- string imports
 
diff --git a/Data/String/Conversions/Monomorphic.hs b/Data/String/Conversions/Monomorphic.hs
new file mode 100644
--- /dev/null
+++ b/Data/String/Conversions/Monomorphic.hs
@@ -0,0 +1,95 @@
+{-# LANGUAGE FlexibleContexts #-}
+
+-- | Monomorphic conversion functions that are useful when you wish to
+-- be explicit about the conversion without writing a type signature
+-- or when 'Data.String.Conversions.cs' is ambiguous due to
+-- polymorphic inputs or outputs.
+--
+-- All functions in this module have 'Data.String.Conversions.cs' as
+-- their implementation.
+module Data.String.Conversions.Monomorphic (
+    -- * From a polymorphic input to a monomorphic output
+    toString,
+    toStrictByteString,
+    toSBS,
+    toLazyByteString,
+    toLBS,
+    toStrictText,
+    toST,
+    toLazyText,
+    toLT,
+
+    -- * From a monomorphic input to a polymorphic output
+
+    fromString,
+    fromStrictByteString,
+    fromSBS,
+    fromLazyByteString,
+    fromLBS,
+    fromStrictText,
+    fromST,
+    fromLazyText,
+    fromLT
+  ) where
+
+import Prelude (String)
+
+import Data.String.Conversions
+
+-- to a monomorphic type
+
+toString :: ConvertibleStrings a String => a -> String
+toString = cs
+
+toStrictByteString :: ConvertibleStrings a StrictByteString => a -> StrictByteString
+toStrictByteString = cs
+
+toSBS :: ConvertibleStrings a SBS => a -> SBS
+toSBS = cs
+
+toLazyByteString :: ConvertibleStrings a LazyByteString => a -> LazyByteString
+toLazyByteString = cs
+
+toLBS :: ConvertibleStrings a LBS => a -> LBS
+toLBS = cs
+
+toStrictText :: ConvertibleStrings a StrictText => a -> StrictText
+toStrictText = cs
+
+toST :: ConvertibleStrings a ST => a -> ST
+toST = cs
+
+toLazyText :: ConvertibleStrings a LazyText => a -> LazyText
+toLazyText = cs
+
+toLT :: ConvertibleStrings a LT => a -> LT
+toLT = cs
+
+-- from a monomorphic type
+
+fromString :: ConvertibleStrings String a => String -> a
+fromString = cs
+
+fromStrictByteString :: ConvertibleStrings StrictByteString a => StrictByteString -> a
+fromStrictByteString = cs
+
+fromSBS :: ConvertibleStrings SBS a => SBS -> a
+fromSBS = cs
+
+fromLazyByteString :: ConvertibleStrings LazyByteString a => LazyByteString -> a
+fromLazyByteString = cs
+
+fromLBS :: ConvertibleStrings LBS a => LBS -> a
+fromLBS = cs
+
+fromStrictText :: ConvertibleStrings StrictText a => StrictText -> a
+fromStrictText = cs
+
+fromST :: ConvertibleStrings ST a => ST -> a
+fromST = cs
+
+fromLazyText :: ConvertibleStrings LazyText a => LazyText -> a
+fromLazyText = cs
+
+fromLT :: ConvertibleStrings LT a => LT -> a
+fromLT = cs
diff --git a/string-conversions.cabal b/string-conversions.cabal
--- a/string-conversions.cabal
+++ b/string-conversions.cabal
@@ -2,7 +2,7 @@
 -- documentation, see http://haskell.org/cabal/users-guide/
 
 name:                string-conversions
-version:             0.3.0.3
+version:             0.4
 synopsis:            Simplifies dealing with different types for strings
 description:         Provides a simple type class for converting values
                      of different string types
@@ -10,7 +10,7 @@
 license:             BSD3
 license-file:        LICENSE
 author:              Sönke Hahn
-maintainer:          shahn@joyridelabs.de
+maintainer:          soenkehahn@gmail.com
 -- copyright:
 category:            Data
 build-type:          Simple
@@ -21,7 +21,8 @@
   location: https://github.com/soenkehahn/string-conversions.git
 
 library
-  exposed-modules:     Data.String.Conversions
+  exposed-modules:     Data.String.Conversions,
+                       Data.String.Conversions.Monomorphic
   build-depends:
     base < 5,
     bytestring >= 0.9,