diff --git a/ip.cabal b/ip.cabal
--- a/ip.cabal
+++ b/ip.cabal
@@ -1,5 +1,5 @@
 name: ip
-version: 1.1.1
+version: 1.1.2
 synopsis: Library for IP and MAC addresses
 homepage: https://github.com/andrewthad/haskell-ip#readme
 license: BSD3
@@ -81,7 +81,6 @@
     IPv4Text1
     IPv4Text2
     IPv4ByteString1
-    -- IPv4TextVariableBuilder
   ghc-options: -Wall -O2
   default-language: Haskell2010
 
@@ -112,7 +111,6 @@
     IPv4DecodeText1
     IPv4DecodeText2
     IPv4ByteString1
-    IPv4TextVariableBuilder
   ghc-options: -Wall -O2
   default-language: Haskell2010
   hs-source-dirs: test
diff --git a/src/Data/Text/Builder/Common/Internal.hs b/src/Data/Text/Builder/Common/Internal.hs
--- a/src/Data/Text/Builder/Common/Internal.hs
+++ b/src/Data/Text/Builder/Common/Internal.hs
@@ -3,22 +3,11 @@
 import Data.Text (Text)
 import Control.Monad.ST
 import Data.Monoid
-import Data.Word
-import Data.Bits
 import Text.Printf
-import Debug.Trace
 import Data.Char (ord)
-import Data.Vector (Vector)
 import Data.Foldable (fold)
-import qualified Data.Vector as Vector
 import qualified Data.Text as Text
-import qualified Data.Text.Lazy as LText
-import qualified Data.Text.Lazy.IO as LText
-import qualified Data.Text.Lazy.Builder as TBuilder
-import qualified Data.Text.Lazy.Builder.Int as TBuilder
-import qualified Data.Text.IO as Text
 import qualified Data.Text.Array as A
-import qualified Data.Text.Internal as TI
 import qualified Data.Text.Internal.Unsafe.Char as TC
 
 -- | This is slower that just pattern matching on the Text data constructor.
diff --git a/src/Data/Text/Builder/Variable.hs b/src/Data/Text/Builder/Variable.hs
--- a/src/Data/Text/Builder/Variable.hs
+++ b/src/Data/Text/Builder/Variable.hs
@@ -22,17 +22,13 @@
   , word8
   ) where
 
-import Data.Monoid
 import Data.Word
 import Data.Text (Text)
-import Text.Printf (printf)
 import Control.Monad.ST
 import Data.Char (ord)
 import Data.Vector (Vector)
-import Data.Function (on)
 import Data.Maybe (fromMaybe)
 import qualified Data.Vector as Vector
-import qualified Data.Text as Text
 import qualified Data.Text.Array as A
 import qualified Data.Text.Builder.Common.Internal as I
 import qualified Data.Text.Internal as TI
@@ -103,21 +99,21 @@
 {-# INLINE word8 #-}
 
 -- This has not yet been tested.
-vector ::
+_vector ::
      Text -- ^ Default, used when index is out of range
   -> Vector Text -- ^ Texts to index into
   -> Builder Int
-vector tDef v =
+_vector tDef v =
   let xs = Vector.map I.portableUntext v
       xDef = I.portableUntext tDef
    in Builder
         (Vector.maximum $ Vector.map I.portableTextLength $ Vector.cons tDef v)
-        $ \pos marr i -> do
+        $ \_ marr i -> do
           let (arr,len) = fromMaybe xDef (xs Vector.!? i)
               finalIx = i + len
           A.copyI marr i arr 0 finalIx
           return finalIx
-{-# INLINE vector #-}
+{-# INLINE _vector #-}
 
 i2w :: Integral a => a -> Word16
 i2w v = asciiZero + fromIntegral v
diff --git a/src/Data/Word/Synthetic/Word12.hs b/src/Data/Word/Synthetic/Word12.hs
--- a/src/Data/Word/Synthetic/Word12.hs
+++ b/src/Data/Word/Synthetic/Word12.hs
@@ -29,7 +29,6 @@
 import           Data.Bits
 import           Data.Data
 import           Data.Maybe
-import           Foreign.Storable
 
 import           GHC.Arr
 import           GHC.Base
diff --git a/src/Net/IP.hs b/src/Net/IP.hs
--- a/src/Net/IP.hs
+++ b/src/Net/IP.hs
@@ -36,10 +36,13 @@
     -- ** Text
   , encode
   , decode
+    -- ** Printing
+  , print
     -- * Types
   , IP(..)
   ) where
 
+import Prelude hiding (print)
 import Data.Bits
 import Net.IPv6 (IPv6(..))
 import Net.IPv4 (IPv4(..))
@@ -51,6 +54,7 @@
 import qualified Net.IPv4 as IPv4
 import qualified Net.IPv6 as IPv6
 import qualified Data.Aeson as Aeson
+import qualified Data.Text.IO as TIO
 
 case_ :: (IPv4 -> a) -> (IPv6 -> a) -> IP -> a
 case_ f g (IP addr@(IPv6 w1 w2)) = if w1 == 0 && (0xFFFFFFFF00000000 .&. w2 == 0x0000FFFF00000000)
@@ -84,6 +88,9 @@
     Nothing -> Nothing
     Just v6 -> Just (fromIPv6 v6)
   Just v4 -> Just (fromIPv4 v4)
+
+print :: IP -> IO ()
+print = TIO.putStrLn . encode
 
 -- | A 32-bit 'IPv4' address or a 128-bit 'IPv6' address. Internally, this
 --   is just represented as an 'IPv6' address. The functions provided
diff --git a/src/Net/IPv4.hs b/src/Net/IPv4.hs
--- a/src/Net/IPv4.hs
+++ b/src/Net/IPv4.hs
@@ -25,6 +25,7 @@
   ( -- * Conversion Functions
     ipv4
   , fromOctets
+  , fromTupleOctets
   , toOctets
     -- * Special IP Addresses
   , any
@@ -40,7 +41,7 @@
   , decode
   , builder
   , reader
-  , parser
+  , parser 
     -- ** UTF-8 ByteString
   , encodeUtf8
   , decodeUtf8
@@ -50,11 +51,13 @@
     -- $string
   , encodeString
   , decodeString
+    -- ** Printing
+  , print
     -- * Types
   , IPv4(..)
   ) where
 
-import Prelude hiding (any)
+import Prelude hiding (any, print)
 import Data.Bits ((.&.),(.|.),shiftR,shiftL,unsafeShiftR)
 import Data.Word
 import Data.Hashable
@@ -94,6 +97,7 @@
 import qualified Data.Aeson.Types as Aeson
 import qualified Data.ByteString.Builder as BB
 import qualified Data.Text.Array as TArray
+import qualified Data.Text.IO as TIO
 
 #if MIN_VERSION_aeson(1,0,0) 
 import Data.Aeson (ToJSONKey(..),FromJSONKey(..),
@@ -131,6 +135,10 @@
 fromOctets a b c d = fromOctets'
   (fromIntegral a) (fromIntegral b) (fromIntegral c) (fromIntegral d)
 
+-- | An uncurried variant of 'fromOctets'.
+fromTupleOctets :: (Word8,Word8,Word8,Word8) -> IPv4
+fromTupleOctets (a,b,c,d) = fromOctets a b c d
+
 -- | Convert an 'IPv4' address into a quadruple of octets. The first
 --   element in the quadruple is the most significant octet. The last
 --   element is the least significant octet.
@@ -319,7 +327,10 @@
 decodeString = decode . Text.pack
 
 
--- | A 32-bit Internet Protocol version 4 address.
+-- | A 32-bit Internet Protocol version 4 address. To use this with the
+--   @network@ library, it is necessary to use @Network.Socket.htonl@ to
+--   convert the underlying 'Word32' from host byte order to network byte
+--   order.
 newtype IPv4 = IPv4 { getIPv4 :: Word32 }
   deriving (Eq,Ord,Enum,Bounded,Hashable,Generic,Prim,Bits,FiniteBits,Storable)
 
@@ -345,6 +356,8 @@
     d <- step readPrec
     return (fromOctets a b c d)
     
+print :: IPv4 -> IO ()
+print = TIO.putStrLn . encode
 
 newtype instance UVector.MVector s IPv4 = MV_IPv4 (PVector.MVector s IPv4)
 newtype instance UVector.Vector IPv4 = V_IPv4 (PVector.Vector IPv4)
diff --git a/src/Net/IPv6.hs b/src/Net/IPv6.hs
--- a/src/Net/IPv6.hs
+++ b/src/Net/IPv6.hs
@@ -9,7 +9,11 @@
   , ipv6
   , fromOctets
   , fromWord16s
+  , fromWord32s
+  , fromTupleWord16s
+  , fromTupleWord32s
   , toWord16s
+  , toWord32s
     -- * Special IP Addresses
   , any
   , loopback
@@ -18,9 +22,11 @@
   , encode
   , decode
   , parser
+    -- ** Printing
+  , print
   ) where
 
-import Prelude hiding (any)
+import Prelude hiding (any, print)
 import Data.Bits
 import Data.List (intercalate, group)
 import Data.Word
@@ -30,6 +36,7 @@
 import Text.Read (Read(..),Lexeme(Ident),lexP,parens)
 import Text.ParserCombinators.ReadPrec (prec,step)
 import qualified Data.Text as Text
+import qualified Data.Text.IO as TIO
 import qualified Data.Attoparsec.Text as Atto
 import qualified Data.Aeson as Aeson
 import qualified Data.Attoparsec.Text as AT
@@ -70,6 +77,9 @@
     where
     (a,b,c,d,e,f,g,h) = toWord16s addr
 
+print :: IPv6 -> IO ()
+print = TIO.putStrLn . encode
+
 showHexWord16 :: Word16 -> ShowS
 showHexWord16 w =
     showString "0x"
@@ -150,6 +160,7 @@
         (fromIntegral e) (fromIntegral f) (fromIntegral g) (fromIntegral h)
    in IPv6 w1 w2
 
+-- | Convert an 'IPv6' to eight 16-bit words.
 toWord16s :: IPv6 -> (Word16,Word16,Word16,Word16,Word16,Word16,Word16,Word16)
 toWord16s (IPv6 a b) =
   ( fromIntegral (unsafeShiftR a 48)
@@ -162,6 +173,31 @@
   , fromIntegral b
   )
 
+-- | Uncurried variant of 'fromWord16s'.
+fromTupleWord16s :: (Word16,Word16,Word16,Word16,Word16,Word16,Word16,Word16) -> IPv6
+fromTupleWord16s (a,b,c,d,e,f,g,h) = fromWord16s a b c d e f g h
+
+-- | Build an 'IPv6' from four 32-bit words. The leftmost argument
+--   is the high word and the rightword is the low word.
+fromWord32s :: Word32 -> Word32 -> Word32 -> Word32 -> IPv6
+fromWord32s a b c d =
+  let !(w1,w2) = fromWord32sV6
+        (fromIntegral a) (fromIntegral b) (fromIntegral c) (fromIntegral d)
+   in IPv6 w1 w2
+
+-- | Uncurried variant of 'fromWord32s'.
+fromTupleWord32s :: (Word32,Word32,Word32,Word32) -> IPv6
+fromTupleWord32s (a,b,c,d) = fromWord32s a b c d
+
+-- | Convert an 'IPv6' to four 32-bit words.
+toWord32s :: IPv6 -> (Word32,Word32,Word32,Word32)
+toWord32s (IPv6 a b) =
+  ( fromIntegral (unsafeShiftR a 32)
+  , fromIntegral a
+  , fromIntegral (unsafeShiftR b 32)
+  , fromIntegral b
+  )
+
 loopback :: IPv6
 loopback = IPv6 0 1
 
@@ -311,6 +347,12 @@
   , fromWord16Word64 e f g h
   )
 
+fromWord32sV6 :: Word64 -> Word64 -> Word64 -> Word64 -> (Word64,Word64)
+fromWord32sV6 a b c d =
+  ( fromWord32Word64 a b
+  , fromWord32Word64 c d
+  )
+
 fromOctetsWord64 ::
      Word64 -> Word64 -> Word64 -> Word64
   -> Word64 -> Word64 -> Word64 -> Word64
@@ -333,4 +375,7 @@
   .|. unsafeShiftL c 16
   .|. d
     )
+
+fromWord32Word64 :: Word64 -> Word64 -> Word64
+fromWord32Word64 a b = fromIntegral (unsafeShiftL a 32 .|. b)
 
diff --git a/src/Net/Mac.hs b/src/Net/Mac.hs
--- a/src/Net/Mac.hs
+++ b/src/Net/Mac.hs
@@ -34,12 +34,15 @@
   , parserWithUtf8
     -- ** ByteString
   , decodeBytes
+    -- ** Printing
+  , print
     -- * Types
   , Mac(..)
   , MacCodec(..)
   , MacGrouping(..)
   ) where
 
+import Prelude hiding (print)
 import Data.Word
 import Data.Bits ((.|.),unsafeShiftL,unsafeShiftR,(.&.))
 import Data.Text (Text)
@@ -64,6 +67,7 @@
 import qualified Data.ByteString.Builder.Fixed as BFB
 import qualified Data.Aeson as Aeson
 import qualified Data.Aeson.Types as Aeson
+import qualified Data.Text.IO as TIO
 
 #if MIN_VERSION_aeson(1,0,0) 
 import Data.Aeson (ToJSONKey(..),FromJSONKey(..),
@@ -555,6 +559,9 @@
     Ident "mac" <- lexP
     w <- step readPrec
     return (mac w)
+
+print :: Mac -> IO ()
+print = TIO.putStrLn . encode
 
 showHexWord48 :: Word64 -> ShowS
 showHexWord48 w = showString "0x" . go 11
diff --git a/test/Bench.hs b/test/Bench.hs
--- a/test/Bench.hs
+++ b/test/Bench.hs
@@ -2,20 +2,7 @@
 
 import Criterion.Main
 import Net.Types (IPv4(..),MacGrouping(..),MacCodec(..))
-import Data.Bits ((.&.),(.|.),shiftR,shiftL,complement)
-import Data.Monoid ((<>))
-import Data.Text.Lazy.Builder.Int (decimal)
-import Data.Text.Internal (Text(..))
-import Data.Word
-import Data.ByteString (ByteString)
-import Control.Monad.ST
 import qualified Data.Text as Text
-import qualified Data.ByteString.Char8 as BC8
-import qualified Data.ByteString as ByteString
-import qualified Data.ByteString.Unsafe as ByteString
-import qualified Data.Text.Lazy as LText
-import qualified Data.Text.Lazy.Builder as TBuilder
-import qualified Data.Text.Array as TArray
 import qualified Net.Mac as Mac
 import qualified Net.IPv4 as IPv4
 
diff --git a/test/IPv4ByteString1.hs b/test/IPv4ByteString1.hs
--- a/test/IPv4ByteString1.hs
+++ b/test/IPv4ByteString1.hs
@@ -1,7 +1,6 @@
 module IPv4ByteString1 where
 
 import Net.Types (IPv4(..))
-import Net.IPv4
 
 import Data.ByteString.Internal as I
 import Data.Bits
diff --git a/test/IPv4DecodeText1.hs b/test/IPv4DecodeText1.hs
--- a/test/IPv4DecodeText1.hs
+++ b/test/IPv4DecodeText1.hs
@@ -1,20 +1,12 @@
 module IPv4DecodeText1 where
 
 import Net.Types
-import Data.Monoid ((<>))
 import Data.Word
-import Data.Bits ((.&.),(.|.),shiftR,shiftL,complement)
-import Control.Monad.ST
 import Data.Text.Internal (Text(..))
-import Data.Text.Lazy.Builder.Int (decimal)
 import Control.Monad
+import Data.Bits ((.|.),shiftL)
 import qualified Data.Text              as Text
-import qualified Data.Text.Lazy         as LText
-import qualified Data.Attoparsec.Text   as AT
-import qualified Data.Text.Array        as TArray
-import qualified Data.Text.Lazy.Builder as TBuilder
 import qualified Data.Text.Read         as TextRead
-import qualified Data.Text.Lazy.Builder.Int as TBuilder
 
 stripDecimal :: Text -> Either String Text
 stripDecimal t = case Text.uncons t of
diff --git a/test/IPv4DecodeText2.hs b/test/IPv4DecodeText2.hs
--- a/test/IPv4DecodeText2.hs
+++ b/test/IPv4DecodeText2.hs
@@ -1,20 +1,10 @@
 module IPv4DecodeText2 where
 
 import Net.Types
-import Data.Monoid ((<>))
 import Data.Word
-import Data.Bits ((.&.),(.|.),shiftR,shiftL,complement)
-import Control.Monad.ST
+import Data.Bits (shiftL,(.|.))
 import Data.Text.Internal (Text(..))
-import Data.Text.Lazy.Builder.Int (decimal)
-import Control.Monad
-import qualified Data.Text              as Text
-import qualified Data.Text.Lazy         as LText
 import qualified Data.Attoparsec.Text   as AT
-import qualified Data.Text.Array        as TArray
-import qualified Data.Text.Lazy.Builder as TBuilder
-import qualified Data.Text.Read         as TextRead
-import qualified Data.Text.Lazy.Builder.Int as TBuilder
 
 dotDecimalParser :: AT.Parser Word32
 dotDecimalParser = fromOctets'
diff --git a/test/IPv4Text1.hs b/test/IPv4Text1.hs
--- a/test/IPv4Text1.hs
+++ b/test/IPv4Text1.hs
@@ -2,22 +2,15 @@
 
 import Net.Types (IPv4(..))
 import Data.Text (Text)
-import qualified Net.IPv4 as IPv4
-import qualified Data.Text as Text
-import Text.Read (readMaybe)
-import Data.Bits ((.&.),(.|.),shiftR,shiftL,complement)
 import Data.Monoid ((<>))
-import Data.Text.Lazy.Builder.Int (decimal)
 import Data.Text.Internal (Text(..))
 import Data.Word
 import Data.ByteString (ByteString)
 import Control.Monad.ST
-import Data.Text.Encoding (encodeUtf8)
+import Data.Bits (shiftR,(.&.))
 import qualified Data.ByteString.Char8  as BC8
 import qualified Data.ByteString        as ByteString
 import qualified Data.ByteString.Unsafe as ByteString
-import qualified Data.Text.Lazy         as LText
-import qualified Data.Text.Lazy.Builder as TBuilder
 import qualified Data.Text.Array        as TArray
 
 ------------------------
@@ -34,7 +27,6 @@
       w2 = fromIntegral $ 255 .&. shiftR w 16
       w3 = fromIntegral $ 255 .&. shiftR w 8
       w4 = fromIntegral $ 255 .&. w
-      dot = 46
       (arr,len) = runST $ do
         marr <- TArray.new 15
         i1 <- putAndCount 0 w1 marr
diff --git a/test/IPv4Text2.hs b/test/IPv4Text2.hs
--- a/test/IPv4Text2.hs
+++ b/test/IPv4Text2.hs
@@ -2,23 +2,11 @@
 
 import Net.Types (IPv4(..))
 import Data.Text (Text)
-import qualified Net.IPv4 as IPv4
-import qualified Data.Text as Text
-import Text.Read (readMaybe)
-import Data.Bits ((.&.),(.|.),shiftR,shiftL,complement)
+import Data.Bits ((.&.),shiftR)
 import Data.Monoid ((<>))
 import Data.Text.Lazy.Builder.Int (decimal)
-import Data.Text.Internal (Text(..))
-import Data.Word
-import Data.ByteString (ByteString)
-import Control.Monad.ST
-import Data.Text.Encoding (encodeUtf8)
-import qualified Data.ByteString.Char8  as BC8
-import qualified Data.ByteString        as ByteString
-import qualified Data.ByteString.Unsafe as ByteString
 import qualified Data.Text.Lazy         as LText
 import qualified Data.Text.Lazy.Builder as TBuilder
-import qualified Data.Text.Array        as TArray
 
 -----------------------------------------
 -- Text Builder implementation. This ends
diff --git a/test/IPv4TextVariableBuilder.hs b/test/IPv4TextVariableBuilder.hs
deleted file mode 100644
--- a/test/IPv4TextVariableBuilder.hs
+++ /dev/null
@@ -1,30 +0,0 @@
-module IPv4TextVariableBuilder where
-
-import Net.Types (IPv4(..))
-import Data.Text (Text)
-import Data.Monoid
-import Data.Word
-import Data.Bits
-import qualified Net.IPv4 as IPv4
-import qualified Data.Text as Text
-import qualified Data.Text.Builder.Variable as VB
-
-encode :: IPv4 -> Text
-encode = VB.run variableBuilder
-
-variableBuilder :: VB.Builder IPv4
-variableBuilder =
-  VB.contramap (word8At 24) VB.word8
-  <> VB.staticCharBmp '.'
-  <> VB.contramap (word8At 16) VB.word8
-  <> VB.staticCharBmp '.'
-  <> VB.contramap (word8At 8) VB.word8
-  <> VB.staticCharBmp '.'
-  <> VB.contramap (word8At 0) VB.word8
-
-word8At :: Int -> IPv4 -> Word8
-word8At i (IPv4 w) = fromIntegral (unsafeShiftR w i)
-{-# INLINE word8At #-}
-
-
-
diff --git a/test/Naive.hs b/test/Naive.hs
--- a/test/Naive.hs
+++ b/test/Naive.hs
@@ -5,17 +5,8 @@
 import qualified Net.IPv4 as IPv4
 import qualified Data.Text as Text
 import Text.Read (readMaybe)
-import Data.Bits ((.&.),(.|.),shiftR,shiftL,complement)
-import Data.Monoid ((<>))
-import Data.Text.Lazy.Builder.Int (decimal)
-import Data.Text.Internal (Text(..))
-import Data.Word
 import Data.ByteString (ByteString)
-import Control.Monad.ST
 import Data.Text.Encoding (encodeUtf8)
-import qualified Data.ByteString.Char8 as BC8
-import qualified Data.ByteString as ByteString
-import qualified Data.Text.Lazy as LText
 
 encodeByteString :: IPv4 -> ByteString
 encodeByteString = encodeUtf8 . encodeText