diff --git a/Text/Shakespeare.hs b/Text/Shakespeare.hs
--- a/Text/Shakespeare.hs
+++ b/Text/Shakespeare.hs
@@ -138,6 +138,7 @@
 eShowErrors = either (error . show) id
 
 contentFromString :: ShakespeareSettings -> String -> [Content]
+contentFromString _ "" = []
 contentFromString rs s =
     compressContents $ eShowErrors $ parse (parseContents rs) s s
   where
diff --git a/Text/Shakespeare/Base.hs b/Text/Shakespeare/Base.hs
--- a/Text/Shakespeare/Base.hs
+++ b/Text/Shakespeare/Base.hs
@@ -35,6 +35,7 @@
 import qualified System.IO as SIO
 import qualified Data.Text.Lazy.IO as TIO
 import Control.Monad (when)
+import Control.Applicative ((<*))
 
 newtype Ident = Ident String
     deriving (Show, Eq, Read, Data, Typeable)
@@ -48,6 +49,7 @@
            | DerefString String
            | DerefBranch Deref Deref
            | DerefList [Deref]
+           | DerefTuple [Deref]
     deriving (Show, Eq, Read, Data, Typeable)
 
 instance Lift Ident where
@@ -76,16 +78,24 @@
         return $ dr `AppE` InfixE (Just n) per (Just d)
     lift (DerefString s) = [|DerefString|] `appE` lift s
     lift (DerefList x) = [|DerefList $(lift x)|]
+    lift (DerefTuple x) = [|DerefTuple $(lift x)|]
 
 derefParens, derefCurlyBrackets :: Parser Deref
 derefParens        = between (char '(') (char ')') parseDeref
 derefCurlyBrackets = between (char '{') (char '}') parseDeref
 
-derefList :: Parser Deref
+derefList, derefTuple :: Parser Deref
 derefList = between (char '[') (char ']') (fmap DerefList $ sepBy parseDeref (char ','))
+derefTuple = try $ do
+  _ <- char '('
+  x <- sepBy1 parseDeref (char ',')
+  when (length x < 2) $ pzero
+  _ <- char ')'
+  return $ DerefTuple x
 
 parseDeref :: Parser Deref
-parseDeref = skipMany (oneOf " \t") >> (derefList <|> (do
+parseDeref = skipMany (oneOf " \t") >> (derefList <|>
+                                        derefTuple <|> (do
     x <- derefSingle
     (derefInfix x) <|> (do
         res <- deref' $ (:) x
@@ -95,21 +105,20 @@
     delim = (many1 (char ' ') >> return())
             <|> lookAhead (oneOf "(\"" >> return ())
     derefOp = try $ do
-        _ <- char '('
-        x <- many1 $ noneOf " \t\n\r()"
-        _ <- char ')'
-        return $ DerefIdent $ Ident x
+            _ <- char '('
+            x <- many1 $ noneOf " \t\n\r()"
+            _ <- char ')'
+            return $ DerefIdent $ Ident x
     derefInfix x = try $ do
-        () <- fail "Infix operator handling is currently disabled"
-        _ <- many1 $ oneOf " \t"
+        _ <- delim
+        xs <- many $ try $ derefSingle <* delim
         op <- many1 (satisfy $ \c -> isSymbol c || c `elem` "-") <?> "operator"
         -- special handling for $, which we don't deal with
         when (op == "$") $ fail "don't handle $"
         let op' = DerefIdent $ Ident op
-        _ <- many1 (oneOf " \t")
-        y <- derefSingle
-        return $ DerefBranch (DerefBranch op' x) y
-    derefSingle = derefOp <|> derefParens <|> numeric <|> strLit<|> ident
+        ys <- many1 $ delim >> derefSingle
+        return $ DerefBranch (DerefBranch op' $ foldl1 DerefBranch $ x : xs) (foldl1 DerefBranch ys)
+    derefSingle = derefTuple <|> derefOp <|> derefParens <|> numeric <|> strLit<|> ident
     deref' lhs =
         dollar <|> derefSingle'
                <|> return (foldl1 DerefBranch $ lhs [])
@@ -176,6 +185,7 @@
 derefToExp _ (DerefRational r) = LitE $ RationalL r
 derefToExp _ (DerefString s) = LitE $ StringL s
 derefToExp s (DerefList ds) = ListE $ map (derefToExp s) ds
+derefToExp s (DerefTuple ds) = TupE $ map (derefToExp s) ds
 
 -- FIXME shouldn't we use something besides a list here?
 flattenDeref :: Deref -> Maybe [String]
diff --git a/shakespeare.cabal b/shakespeare.cabal
--- a/shakespeare.cabal
+++ b/shakespeare.cabal
@@ -1,5 +1,5 @@
 name:            shakespeare
-version:         1.0.0.2
+version:         1.0.1
 license:         MIT
 license-file:    LICENSE
 author:          Michael Snoyman <michael@snoyman.com>
diff --git a/test.hs b/test.hs
new file mode 100644
--- /dev/null
+++ b/test.hs
@@ -0,0 +1,5 @@
+import Test.Hspec.Monadic
+import ShakespeareBaseTest (specs)
+
+main :: IO ()
+main = hspecX $ specs