diff --git a/Text/Pandoc/Builder.hs b/Text/Pandoc/Builder.hs
--- a/Text/Pandoc/Builder.hs
+++ b/Text/Pandoc/Builder.hs
@@ -1,4 +1,5 @@
-{-# LANGUAGE TypeSynonymInstances, FlexibleInstances #-}
+{-# LANGUAGE TypeSynonymInstances, FlexibleInstances, MultiParamTypeClasses,
+    DeriveDataTypeable, GeneralizedNewtypeDeriving #-}
 {-
 Copyright (C) 2010 John MacFarlane <jgm@berkeley.edu>
 
@@ -28,16 +29,17 @@
 
 Convenience functions for building pandoc documents programmatically.
 
-Example of use (requires the @OverloadedStrings@ language extension):
+Example of use:
 
+> {-# LANGUAGE OverloadedStrings #-}
 > import Text.Pandoc.Builder
 >
 > myDoc :: Pandoc
 > myDoc = setTitle "My title" $ doc $
->   para "This is the first paragraph" +++
->   para ("And " +++ emph "another" +++ ".") +++
->   bulletList [ para "item one" +++ para "continuation"
->              , plain ("item two and a " +++
+>   para "This is the first paragraph" <>
+>   para ("And " <> emph "another" <> ".") <>
+>   bulletList [ para "item one" <> para "continuation"
+>              , plain ("item two and a " <>
 >                  link "/url" "go to url" "link")
 >              ]
 
@@ -83,12 +85,11 @@
 -}
 
 module Text.Pandoc.Builder ( module Text.Pandoc.Definition
-                           , Inlines
-                           , Blocks
-                           , toList
-                           , fromList
+                           , Inlines(..)
+                           , Blocks(..)
                            , empty
-                           , (+++)
+                           , (<>)
+                           , Listable(..)
                            -- * Document builders
                            , doc
                            , setTitle
@@ -109,10 +110,6 @@
                            , codeWith
                            , code
                            , space
-                           , ellipses
-                           , emdash
-                           , endash
-                           , apostrophe
                            , linebreak
                            , math
                            , displayMath
@@ -120,6 +117,7 @@
                            , link
                            , image
                            , note
+                           , trimInlines
                            -- * Block list builders
                            , para
                            , plain
@@ -141,25 +139,88 @@
 import Data.String
 import Data.Monoid
 import Data.Maybe (fromMaybe)
-import Data.Sequence (Seq, fromList, singleton, empty, (><))
-import Data.Foldable (Foldable, toList)
-import Data.List (groupBy)
+import Data.Sequence (Seq, (|>), empty, viewr, viewl, ViewR(..), ViewL(..))
+import qualified Data.Sequence as Seq
+import Data.Foldable (Foldable)
+import qualified Data.Foldable as F
+import Data.List (groupBy, intersperse)
+import Data.Data
+import Data.Typeable
 import Control.Arrow ((***))
 
-type Inlines = Seq Inline
+(<>) :: Monoid a => a -> a -> a
+(<>) = mappend
 
--- Foldable gives us toList
--- Monoid gives us mappend, mempty
+newtype Inlines = Inlines { unInlines :: Seq Inline }
+                deriving (Data, Ord, Eq, Typeable)
 
+-- We show an Inlines just like [Inline].
+instance Show Inlines where
+  show = show . F.toList . unInlines
+
+instance Read Inlines where
+  readsPrec n = map (\(x,y) -> (Inlines . Seq.fromList $ x, y)) . readsPrec n
+
+instance Monoid Inlines where
+  mempty = Inlines mempty
+  (Inlines xs) `mappend` (Inlines ys) =
+    case (viewr xs, viewl ys) of
+      (EmptyR, _) -> Inlines ys
+      (_, EmptyL) -> Inlines xs
+      (xs' :> x, y :< ys') -> Inlines (meld `mappend` ys')
+        where meld = case (x, y) of
+                          (Space, Space)     -> xs' |> Space
+                          (Str t1, Str t2)   -> xs' |> Str (t1 <> t2)
+                          (Emph i1, Emph i2) -> xs' |> Emph (i1 <> i2)
+                          (Strong i1, Strong i2) -> xs' |> Strong (i1 <> i2)
+                          (Subscript i1, Subscript i2) -> xs' |> Subscript (i1 <> i2)
+                          (Superscript i1, Superscript i2) -> xs' |> Superscript (i1 <> i2)
+                          (Strikeout i1, Strikeout i2) -> xs' |> Strikeout (i1 <> i2)
+                          (Space, LineBreak) -> xs' |> LineBreak
+                          _                  -> xs' |> x |> y
+
 instance IsString Inlines where
   fromString = text
 
-type Blocks = Seq Block
+newtype Blocks = Blocks { unBlocks :: Seq Block }
+                deriving (Data, Ord, Eq, Typeable, Monoid)
 
--- | Concatenate two 'Inlines's or two 'Blocks's.
-(+++) :: Monoid a => a -> a -> a
-(+++) = mappend
+-- We show a Blocks just like [Block].
+instance Show Blocks where
+  show = show . F.toList . unBlocks
 
+instance Read Blocks where
+  readsPrec n = map (\(x,y) -> (Blocks . Seq.fromList $ x, y)) . readsPrec n
+
+class Listable a b where
+  toList     :: a -> [b]
+  fromList   :: [b] -> a
+  foldMap    :: (b -> a) -> a -> a
+  singleton  :: b -> a
+  foldlM     :: Monad m => (a -> b -> m a) -> a -> a -> m a
+  isNull     :: a -> Bool
+
+instance Listable Inlines Inline where
+  toList         = F.toList . unInlines
+  fromList       = Inlines . Seq.fromList
+  foldMap f      = F.foldMap f . unInlines
+  singleton      = Inlines . Seq.singleton
+  foldlM f x     = F.foldlM f x . unInlines
+  isNull         = Seq.null . unInlines
+
+instance Listable Blocks Block where
+  toList         = F.toList . unBlocks
+  fromList       = Blocks . Seq.fromList
+  foldMap  f     = F.foldMap f . unBlocks
+  singleton      = Blocks . Seq.singleton
+  foldlM f x     = F.foldlM f x . unBlocks
+  isNull         = Seq.null . unBlocks
+
+-- | Trim leading and trailing Sp (spaces) from an Inlines.
+trimInlines :: Inlines -> Inlines
+trimInlines (Inlines ils) = Inlines $ Seq.dropWhileL (== Space) $
+                            Seq.dropWhileR (== Space) $ ils
+
 -- Document builders
 
 doc :: Blocks -> Pandoc
@@ -234,18 +295,6 @@
 space :: Inlines
 space = singleton Space
 
-emdash :: Inlines
-emdash = singleton EmDash
-
-endash :: Inlines
-endash = singleton EnDash
-
-apostrophe :: Inlines
-apostrophe = singleton Apostrophe
-
-ellipses :: Inlines
-ellipses = singleton Ellipses
-
 linebreak :: Inlines
 linebreak = singleton LineBreak
 
@@ -333,7 +382,7 @@
 simpleTable :: [Blocks]   -- ^ Headers
             -> [[Blocks]] -- ^ Rows
             -> Blocks
-simpleTable headers = table empty (mapConst defaults headers) headers
+simpleTable headers = table mempty (mapConst defaults headers) headers
   where defaults = (AlignDefault, 0)
 
 mapConst :: Functor f => b -> f a -> f b
diff --git a/Text/Pandoc/Definition.hs b/Text/Pandoc/Definition.hs
--- a/Text/Pandoc/Definition.hs
+++ b/Text/Pandoc/Definition.hs
@@ -125,10 +125,6 @@
     | Cite [Citation]  [Inline] -- ^ Citation (list of inlines)
     | Code Attr String      -- ^ Inline code (literal)
     | Space                 -- ^ Inter-word space
-    | EmDash                -- ^ Em dash
-    | EnDash                -- ^ En dash
-    | Apostrophe            -- ^ Apostrophe
-    | Ellipses              -- ^ Ellipses
     | LineBreak             -- ^ Hard line break
     | Math MathType String  -- ^ TeX math (literal)
     | RawInline Format String -- ^ Raw inline
diff --git a/pandoc-types.cabal b/pandoc-types.cabal
--- a/pandoc-types.cabal
+++ b/pandoc-types.cabal
@@ -1,5 +1,5 @@
 Name:                pandoc-types
-Version:             1.8.2
+Version:             1.9
 Synopsis:            Types for representing a structured document
 Description:         This package contains definitions for the 'Pandoc' data
                      structure, which is used by pandoc to represent
@@ -34,7 +34,7 @@
                      Text.Pandoc.Generic
                      Text.Pandoc.Builder
   if impl(ghc >= 6.10)
-    Build-depends:     base >= 4 && < 5, syb, containers
+    Build-depends:     base >= 4 && < 5, syb, containers >= 0.3
   else
-    Build-depends:     base >= 3 && < 4, containers
+    Build-depends:     base >= 3 && < 4, containers >= 0.3