diff --git a/bench/MainCriterion.hs b/bench/MainCriterion.hs
--- a/bench/MainCriterion.hs
+++ b/bench/MainCriterion.hs
@@ -1,15 +1,16 @@
-{-# LANGUAGE OverloadedStrings, LambdaCase #-}
+{-# LANGUAGE OverloadedStrings, LambdaCase, RankNTypes #-}
 
 module Main where
 
 import Criterion
 import Criterion.Main
 import Data.RDF
-import qualified Data.Text as T
+import qualified Data.Text.Lazy as T
 
--- The `countries.ttl` Turtle file is needed to run this benchmark suite
+-- The `bills.102.rdf` XML file is needed to run this benchmark suite
 --
--- $ wget http://telegraphis.net/data/countries/countries.ttl
+-- $ wget https://www.govtrack.us/data/rdf/bills.102.rdf.gz
+-- $ gzip -d bills.102.rdf.gz
 
 parseTurtle :: RDF rdf => String -> rdf
 parseTurtle s =
@@ -24,7 +25,7 @@
 
 main :: IO ()
 main = defaultMain [
-   env (readFile "countries.ttl") $ \ ~(ttl_countries) ->
+   env (readFile "bills.102.ttl") $ \ ~(ttl_countries) ->
    bgroup "parse" [
      bench "TriplesGraph" $
        nf (parseTurtle  :: String -> TriplesGraph) ttl_countries
@@ -35,58 +36,56 @@
    ]
 
    ,
-   env (do ttl_countries <- readFile "countries.ttl"
+   env (do ttl_countries <- readFile "bills.102.ttl"
            let (Right rdf1) = parseString (TurtleParser Nothing Nothing) (T.pack ttl_countries)
            let (Right rdf2) = parseString (TurtleParser Nothing Nothing) (T.pack ttl_countries)
            let (Right rdf3) = parseString (TurtleParser Nothing Nothing) (T.pack ttl_countries)
            return (rdf1 :: PatriciaTreeGraph,rdf2 :: TriplesGraph,rdf3 :: MGraph) )
      $ \ ~(patriciaTreeCountries,triplesGraph,mGraph) ->
-   bgroup "query" [
-     bench "TriplesGraph" $
-       nf (queryGr  :: (Maybe Node,Maybe Node,Maybe Node,TriplesGraph) -> [Triple])
-              (Just (UNode "http://telegraphis.net/data/countries/AF#AF"),
-               Just (UNode "geographis:capital"),
-               Just (UNode "http://telegraphis.net/data/capitals/AF/Kabul#Kabul"),
-               triplesGraph)
-   , bench "MGraph" $
-       nf (queryGr  :: (Maybe Node,Maybe Node,Maybe Node,MGraph) -> [Triple])
-              (Just (UNode "http://telegraphis.net/data/countries/AF#AF"),
-               Just (UNode "geographis:capital"),
-               Just (UNode "http://telegraphis.net/data/capitals/AF/Kabul#Kabul"),
-               mGraph)
-   , bench "PatriciaTreeGraph" $
-       nf (queryGr  :: (Maybe Node,Maybe Node,Maybe Node,PatriciaTreeGraph) -> [Triple])
-              (Just (UNode "http://telegraphis.net/data/countries/AF#AF"),
-               Just (UNode "geographis:capital"),
-               Just (UNode "http://telegraphis.net/data/capitals/AF/Kabul#Kabul"),
-               patriciaTreeCountries)
-   ]
+   bgroup "query"
+     (queryBench "TriplesGraph" triplesGraph
+     ++ queryBench "MGraph" mGraph
+     ++ queryBench "PatriciaTreeGraph" patriciaTreeCountries)
 
    ,
-   env (do ttl_countries <- readFile "countries.ttl"
+   env (do ttl_countries <- readFile "bills.102.ttl"
            let (Right rdf1) = parseString (TurtleParser Nothing Nothing) (T.pack ttl_countries)
            let (Right rdf2) = parseString (TurtleParser Nothing Nothing) (T.pack ttl_countries)
            let (Right rdf3) = parseString (TurtleParser Nothing Nothing) (T.pack ttl_countries)
            return (rdf1 :: PatriciaTreeGraph,rdf2 :: TriplesGraph,rdf3 :: MGraph) )
      $ \ ~(patriciaTreeCountries,triplesGraph,mGraph) ->
-   bgroup "select" [
-     bench "TriplesGraph" $
-       nf (selectGr  :: (NodeSelector,NodeSelector,NodeSelector,TriplesGraph) -> [Triple])
-              (Just (\case { (UNode n) -> T.length n > 12 ; _ -> False } ),
-               Just (\case { (UNode n) -> T.length n > 12 ; _ -> False } ),
-               Just (\case { (UNode n) -> T.length n > 12 ; _ -> False } ),
-               triplesGraph)
-   , bench "MGraph" $
-       nf (selectGr  :: (NodeSelector,NodeSelector,NodeSelector,MGraph) -> [Triple])
-              (Just (\case { (UNode n) -> T.length n > 12 ; _ -> False } ),
-               Just (\case { (UNode n) -> T.length n > 12 ; _ -> False } ),
-               Just (\case { (UNode n) -> T.length n > 12 ; _ -> False } ),
-               mGraph)
-   , bench "PatriciaTreeGraph" $
-       nf (selectGr  :: (NodeSelector,NodeSelector,NodeSelector,PatriciaTreeGraph) -> [Triple])
-              (Just (\case { (UNode n) -> T.length n > 12 ; _ -> False } ),
-               Just (\case { (UNode n) -> T.length n > 12 ; _ -> False } ),
-               Just (\case { (UNode n) -> T.length n > 12 ; _ -> False } ),
-               patriciaTreeCountries)
-   ]
+   bgroup "select"
+     (selectBench "TriplesGraph" triplesGraph
+     ++ selectBench "MGraph" mGraph
+     ++ selectBench "PatriciaTreeGraph" patriciaTreeCountries)
  ]
+
+selectBench :: forall rdf. RDF rdf => String -> rdf -> [Benchmark]
+selectBench label gr =
+   [ bench (label ++ " SPO") $ nf selectGr (subjSelect,predSelect,objSelect,gr)
+   , bench (label ++ " SP")  $ nf selectGr (subjSelect,predSelect,selectNothing,gr)
+   , bench (label ++ " S")   $ nf selectGr (subjSelect,selectNothing,selectNothing,gr)
+   , bench (label ++ " PO")  $ nf selectGr (selectNothing,predSelect,objSelect,gr)
+   , bench (label ++ " O")   $ nf selectGr (selectNothing,selectNothing,objSelect,gr)
+   ]
+
+subjSelect, predSelect, objSelect, selectNothing :: Maybe (Node -> Bool)
+subjSelect = Just (\case { (UNode n) -> T.length n > 12 ; _ -> False })
+predSelect = Just (\case { (UNode n) -> T.length n > 12 ; _ -> False })
+objSelect  = Just (\case { (UNode n) -> T.length n > 12 ; _ -> False })
+selectNothing = Nothing
+
+subjQuery, predQuery, objQuery, queryNothing :: Maybe Node
+subjQuery = Just (UNode "http://www.rdfabout.com/rdf/usgov/congress/102/bills/h5694")
+predQuery = Just (UNode "bill:congress")
+objQuery  = Just (LNode (PlainL (T.pack "102")))
+queryNothing = Nothing
+
+queryBench :: forall rdf. RDF rdf => String -> rdf -> [Benchmark]
+queryBench label gr =
+   [ bench (label ++ " SPO") $ nf queryGr (subjQuery,predQuery,objQuery,gr)
+   , bench (label ++ " SP")  $ nf queryGr (subjQuery,predQuery,queryNothing,gr)
+   , bench (label ++ " S")   $ nf queryGr (subjQuery,queryNothing,queryNothing,gr)
+   , bench (label ++ " PO")  $ nf queryGr (queryNothing,predQuery,objQuery,gr)
+   , bench (label ++ " O")   $ nf queryGr (queryNothing,queryNothing,objQuery,gr)
+   ]
diff --git a/rdf4h.cabal b/rdf4h.cabal
--- a/rdf4h.cabal
+++ b/rdf4h.cabal
@@ -1,7 +1,7 @@
 name:            rdf4h
-version:         1.3.2
+version:         1.3.3
 synopsis:        A library for RDF processing in Haskell
-description:     
+description:
   'RDF for Haskell' is a library for working with RDF in Haskell.
   At present it includes parsers and serializers for RDF in the N-Triples
   and Turtle, and parsing support for RDF/XML. It provides abilities such as querying
@@ -49,10 +49,10 @@
   else
     build-depends: base < 3
   build-depends:   parsec >= 3
-                 , fgl
+                 , fgl >= 5.5.2.0
                  , HTTP >= 4000.0.0
                  , hxt >= 9.3.1.2
-                 , text
+                 , text >= 1.2.1.0
                  , unordered-containers
                  , hashable
                  , deepseq
@@ -73,20 +73,14 @@
   ghc-options:     -Wall -fno-warn-unused-do-bind -funbox-strict-fields -O2
 
 executable rdf4h
-  main-is:         Rdf4hParseMain.hs 
+  main-is:         src/Rdf4hParseMain.hs
   if flag(small_base)
     build-depends: base >= 3, bytestring
   else
     build-depends: base >= 4 && < 6
-  build-depends:   parsec >= 3
-                 , HTTP >= 4000.0.0
-                 , hxt >= 9.3.1.2
+  build-depends:   rdf4h
                  , containers
-                 , text
-                 , hashable
-                 , deepseq
-                 , binary
-                 , text-binary
+                 , text >= 1.2.1.0
 
   if impl(ghc < 7.6)
     build-depends: ghc-prim
@@ -96,7 +90,6 @@
   else
     build-depends: network-uri < 2.6, network < 2.6
 
-  hs-source-dirs:  src
   extensions:      BangPatterns RankNTypes ScopedTypeVariables MultiParamTypeClasses OverloadedStrings
   ghc-options:     -Wall -fno-warn-unused-do-bind -funbox-strict-fields
 
@@ -106,24 +99,16 @@
   ghc-options:   -Wall -fno-warn-unused-do-bind -fno-warn-orphans -fno-warn-name-shadowing -funbox-strict-fields
   extensions:    RankNTypes MultiParamTypeClasses Arrows FlexibleContexts OverloadedStrings
   build-depends: base >= 4 && < 6
-               , parsec >= 3
+               , rdf4h
                , test-framework >= 0.2.3
                , test-framework-quickcheck2
                , test-framework-hunit >= 0.2.7
-               , HTTP >= 4000.0.0
                , QuickCheck >= 1.2.0.0
                , HUnit >= 1.2.2.1
                , bytestring
-               , hxt >= 9.3.1.2
                , containers
-               , text
+               , text >= 1.2.1.0
                , knob
-               , unordered-containers
-               , hashable
-               , fgl
-               , deepseq
-               , binary
-               , text-binary
 
   if impl(ghc < 7.6)
     build-depends: ghc-prim
@@ -133,18 +118,8 @@
   else
     build-depends: network-uri < 2.6, network < 2.6
 
-  other-modules: Data.RDF
-               , Data.RDF.Namespace
-               , Data.RDF.MGraph
-               , Data.RDF.PatriciaTreeGraph
-               , Data.RDF.TriplesGraph
-               , Text.RDF.RDF4H.NTriplesParser
-               , Text.RDF.RDF4H.NTriplesSerializer
-               , Text.RDF.RDF4H.TurtleParser
-               , Text.RDF.RDF4H.TurtleSerializer
-               , Text.RDF.RDF4H.XmlParser
-               , W3C.TurtleTest
-  hs-source-dirs: src, testsuite/tests
+  other-modules: W3C.TurtleTest
+  hs-source-dirs: testsuite/tests
 
 benchmark rdf4h-bench
   type:             exitcode-stdio-1.0
@@ -153,7 +128,7 @@
   build-depends:    base,
                     criterion,
                     rdf4h,
-                    text
+                    text >= 1.2.1.0
   ghc-options:      -Wall
                     -O2
 
diff --git a/src/Data/RDF/Namespace.hs b/src/Data/RDF/Namespace.hs
--- a/src/Data/RDF/Namespace.hs
+++ b/src/Data/RDF/Namespace.hs
@@ -14,7 +14,7 @@
   standard_ns_mappings, ns_mappings
 ) where
 
-import qualified Data.Text as T
+import qualified Data.Text.Lazy as T
 import Data.RDF.Types
 import qualified Data.Map as Map
 
diff --git a/src/Data/RDF/PatriciaTreeGraph.hs b/src/Data/RDF/PatriciaTreeGraph.hs
--- a/src/Data/RDF/PatriciaTreeGraph.hs
+++ b/src/Data/RDF/PatriciaTreeGraph.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE GeneralizedNewtypeDeriving, FlexibleInstances, BangPatterns, CPP #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving, FlexibleInstances, BangPatterns #-}
 
 module Data.RDF.PatriciaTreeGraph where
 
@@ -16,16 +16,10 @@
 import Data.Maybe
 
 newtype PatriciaTreeGraph = PatriciaTreeGraph (PT.Gr Node Node,IntMap.IntMap Node, Maybe BaseUrl, PrefixMappings)
-                            deriving (Show,NFData)
+                            deriving (Show)
 
-#if MIN_VERSION_fgl(5,5,2)
--- fgl 7616e7135c9401e98f4c7350c9f60108ea73e456
--- adds those instances but they are not released yet
-#else
--- fgl-5.5.1.0 and older don't have that instance
 instance NFData (PT.Gr Node Node)
   where rnf x = seq x ()
-#endif
 
 instance RDF PatriciaTreeGraph where
   baseUrl           = baseUrl'
diff --git a/src/Data/RDF/Query.hs b/src/Data/RDF/Query.hs
--- a/src/Data/RDF/Query.hs
+++ b/src/Data/RDF/Query.hs
@@ -20,9 +20,10 @@
 import Data.List
 import Data.RDF.Types
 import qualified Data.RDF.Namespace as NS (toPMList, uriOf, rdf)
-import qualified Data.Text as T
+import qualified Data.Text.Lazy as T
 import Data.Maybe (catMaybes)
 
+
 -- |Answer the subject node of the triple.
 {-# INLINE subjectOf #-}
 subjectOf :: Triple -> Node
@@ -101,9 +102,25 @@
 -- node names, triple order and prefixes.  In math terms, this is the \simeq
 -- latex operator, or ~=
 isIsomorphic :: forall rdf1 rdf2. (RDF rdf1, RDF rdf2) => rdf1 -> rdf2 -> Bool
-isIsomorphic g1 g2 = normalize g1 == normalize g2
-  where normalize :: forall rdf. (RDF rdf) => rdf -> Triples
-        normalize = sort . nub . expandTriples
+isIsomorphic g1 g2 = and $ zipWith compareTripleUnlessBlank (normalize g1) (normalize g2)
+  where
+    compareNodeUnlessBlank :: Node -> Node -> Bool
+    compareNodeUnlessBlank (BNode _)     (BNode _)     = True
+    compareNodeUnlessBlank (UNode n1)    (UNode n2)    = n1 == n2
+    compareNodeUnlessBlank (BNodeGen i1) (BNodeGen i2) = i1 == i2
+    compareNodeUnlessBlank (LNode l1)    (LNode l2)    = l1 == l2
+    compareNodeUnlessBlank (BNodeGen _)  (BNode _)     = True
+    compareNodeUnlessBlank (BNode _)     (BNodeGen _)  = True
+    compareNodeUnlessBlank _             _             = False
+
+    compareTripleUnlessBlank :: Triple -> Triple -> Bool
+    compareTripleUnlessBlank (Triple s1 p1 o1) (Triple s2 p2 o2) =
+        compareNodeUnlessBlank s1 s2 &&
+        compareNodeUnlessBlank p1 p2 &&
+        compareNodeUnlessBlank o1 o2
+
+    normalize :: forall rdf. (RDF rdf) => rdf -> Triples
+    normalize = sort . nub . expandTriples
 
 -- |Expand the triples in a graph with the prefix map and base URL for that
 -- graph.
diff --git a/src/Data/RDF/Types.hs b/src/Data/RDF/Types.hs
--- a/src/Data/RDF/Types.hs
+++ b/src/Data/RDF/Types.hs
@@ -36,7 +36,7 @@
 ) where
 
 import Prelude hiding (pred)
-import qualified Data.Text as T
+import qualified Data.Text.Lazy as T
 import System.IO
 import Text.Printf
 import Data.Binary
@@ -45,7 +45,6 @@
 import Data.Hashable(Hashable)
 import qualified Data.List as List
 import qualified Data.Map as Map
-import Data.Text.Binary ()
 import qualified Network.URI as Network (isURI)
 import Control.DeepSeq (NFData,rnf)
 import GHC.Generics ()
diff --git a/src/Rdf4hParseMain.hs b/src/Rdf4hParseMain.hs
--- a/src/Rdf4hParseMain.hs
+++ b/src/Rdf4hParseMain.hs
@@ -12,8 +12,8 @@
 import Text.RDF.RDF4H.TurtleParser
 import Text.RDF.RDF4H.TurtleSerializer
 
-import qualified Data.Text as T
-import qualified Data.Text.IO as TIO
+import qualified Data.Text.Lazy as T
+import qualified Data.Text.Lazy.IO as TIO
 
 import System.Environment
 import System.IO
diff --git a/src/Text/RDF/RDF4H/Interact.hs b/src/Text/RDF/RDF4H/Interact.hs
--- a/src/Text/RDF/RDF4H/Interact.hs
+++ b/src/Text/RDF/RDF4H/Interact.hs
@@ -14,7 +14,7 @@
 
 module Text.RDF.RDF4H.Interact where
 
-import qualified Data.Text as T
+import qualified Data.Text.Lazy as T
 
 import Data.RDF.Types hiding (baseUrl)
 import Data.RDF.TriplesGraph()
diff --git a/src/Text/RDF/RDF4H/NTriplesParser.hs b/src/Text/RDF/RDF4H/NTriplesParser.hs
--- a/src/Text/RDF/RDF4H/NTriplesParser.hs
+++ b/src/Text/RDF/RDF4H/NTriplesParser.hs
@@ -11,9 +11,9 @@
 import Data.Char(isLetter, isDigit, isLower)
 import qualified Data.Map as Map
 import Text.Parsec
-import Text.Parsec.Text
-import qualified Data.Text as T
-import qualified Data.Text.IO as TIO
+import Text.Parsec.Text.Lazy
+import qualified Data.Text.Lazy as T
+import qualified Data.Text.Lazy.IO as TIO
 import Control.Monad (liftM,void)
 
 -- |NTriplesParser is an 'RdfParser' implementation for parsing RDF in the
diff --git a/src/Text/RDF/RDF4H/NTriplesSerializer.hs b/src/Text/RDF/RDF4H/NTriplesSerializer.hs
--- a/src/Text/RDF/RDF4H/NTriplesSerializer.hs
+++ b/src/Text/RDF/RDF4H/NTriplesSerializer.hs
@@ -7,8 +7,9 @@
 
 import Control.Monad (void)
 import Data.RDF.Types
-import qualified Data.Text as T
-import qualified Data.Text.IO as T
+import Data.RDF.Query (expandTriples)
+import qualified Data.Text.Lazy as T
+import qualified Data.Text.Lazy.IO as T
 import System.IO
 
 data NTriplesSerializer = NTriplesSerializer
@@ -26,7 +27,7 @@
   writeN    _     = _writeNode stdout
 
 _writeRdf :: RDF rdf => Handle -> rdf -> IO ()
-_writeRdf h = _writeTriples h . triplesOf
+_writeRdf h = _writeTriples h . expandTriples
 
 _writeTriples :: Handle -> Triples -> IO ()
 _writeTriples h = mapM_ (_writeTriple h)
diff --git a/src/Text/RDF/RDF4H/ParserUtils.hs b/src/Text/RDF/RDF4H/ParserUtils.hs
--- a/src/Text/RDF/RDF4H/ParserUtils.hs
+++ b/src/Text/RDF/RDF4H/ParserUtils.hs
@@ -7,9 +7,9 @@
 import Network.URI
 import Network.HTTP
 import Data.Char (intToDigit)
-import Data.Text.Encoding (decodeUtf8)
-import qualified Data.ByteString.Char8 as B
-import qualified Data.Text as T
+import Data.Text.Lazy.Encoding (decodeUtf8)
+import qualified Data.ByteString.Lazy.Char8 as B
+import qualified Data.Text.Lazy as T
 -- import qualified Data.Map as Map
 import Data.Maybe (fromMaybe)
 
diff --git a/src/Text/RDF/RDF4H/TurtleParser.hs b/src/Text/RDF/RDF4H/TurtleParser.hs
--- a/src/Text/RDF/RDF4H/TurtleParser.hs
+++ b/src/Text/RDF/RDF4H/TurtleParser.hs
@@ -12,10 +12,10 @@
 import Data.RDF.Namespace
 import Text.RDF.RDF4H.ParserUtils
 import Text.Parsec
-import Text.Parsec.Text
+import Text.Parsec.Text.Lazy
 import qualified Data.Map as Map
-import qualified Data.Text as T
-import qualified Data.Text.IO as TIO
+import qualified Data.Text.Lazy as T
+import qualified Data.Text.Lazy.IO as TIO
 import Data.Sequence(Seq, (|>))
 import qualified Data.Sequence as Seq
 import qualified Data.Foldable as F
diff --git a/src/Text/RDF/RDF4H/TurtleSerializer.hs b/src/Text/RDF/RDF4H/TurtleSerializer.hs
--- a/src/Text/RDF/RDF4H/TurtleSerializer.hs
+++ b/src/Text/RDF/RDF4H/TurtleSerializer.hs
@@ -10,8 +10,8 @@
 import Data.RDF.Types
 import Data.RDF.Query
 import Data.RDF.Namespace hiding (rdf)
-import qualified Data.Text as T
-import qualified Data.Text.IO as T
+import qualified Data.Text.Lazy as T
+import qualified Data.Text.Lazy.IO as T
 import Data.Map(Map)
 import qualified Data.Map as Map
 import Data.List
diff --git a/src/Text/RDF/RDF4H/XmlParser.hs b/src/Text/RDF/RDF4H/XmlParser.hs
--- a/src/Text/RDF/RDF4H/XmlParser.hs
+++ b/src/Text/RDF/RDF4H/XmlParser.hs
@@ -13,8 +13,8 @@
 import qualified Data.Map as Map (fromList)
 import Text.RDF.RDF4H.ParserUtils
 import Data.RDF.Types (RDF,RdfParser(..),Node(BNodeGen),BaseUrl(..),Triple(..),Triples,Subject,Predicate,Object,PrefixMappings(..),ParseFailure(ParseFailure),mkRdf,lnode,plainL,plainLL,typedL,unode,bnode)
-import qualified Data.Text as T (Text,pack,unpack)
-import qualified Data.Text.IO as TIO
+import qualified Data.Text.Lazy as T (Text,pack,unpack)
+import qualified Data.Text.Lazy.IO as TIO
 import Text.XML.HXT.Core (ArrowXml,XmlTree,IfThen((:->)),(>.),(>>.),first,neg,(<+>),expandURI,getName,getAttrValue,getAttrValue0,getAttrl,hasAttrValue,hasAttr,constA,choiceA,getChildren,ifA,arr2A,second,hasName,isElem,isWhiteSpace,xshow,listA,isA,isText,getText,this,unlistA,orElse,sattr,mkelem,xreadDoc,runSLA)
 
 -- TODO: write QuickCheck tests for XmlParser instance for RdfParser.
@@ -116,7 +116,7 @@
 parseDescription' :: forall a. (ArrowXml a, ArrowState GParseState a) => a (BaseUrl, XmlTree) Triple
 parseDescription' = proc (bUrl, rdf) -> do
                          desc <- isElem <<< getChildren -< rdf
-                         state <- arr (\(s, o) -> s { stateSubject = o }) <<< arr fst &&& arr2A mkNode -< (LParseState bUrl Nothing undefined, desc)
+                         state <- arr (\(s, o) -> s { stateSubject = o }) <<< arr fst &&& arr2A mkNode <<< updateState -< (LParseState bUrl Nothing undefined, desc)
                          triple <- parseDescription -< (state, desc)
                          returnA -< triple
 
@@ -154,6 +154,7 @@
          <+> isA (== "rdf:ID")
          <+> isA (== "xml:lang")
          <+> isA (== "rdf:parseType")
+         <+> isA (== "xml:base")
 
 -- |Read a children of an rdf:Description element.  These correspond to the Predicate portion of the Triple
 parsePredicatesFromChildren :: forall a. (ArrowXml a, ArrowState GParseState a)
diff --git a/testsuite/tests/W3C/TurtleTest.hs b/testsuite/tests/W3C/TurtleTest.hs
--- a/testsuite/tests/W3C/TurtleTest.hs
+++ b/testsuite/tests/W3C/TurtleTest.hs
@@ -3,7 +3,7 @@
 import Test.Framework.Providers.API
 import Test.Framework.Providers.HUnit
 import qualified Test.HUnit as TU
-import qualified Data.Text as T
+import qualified Data.Text.Lazy as T
 
 import W3C.Manifest