diff --git a/hoppy-std.cabal b/hoppy-std.cabal
--- a/hoppy-std.cabal
+++ b/hoppy-std.cabal
@@ -1,5 +1,5 @@
 name: hoppy-std
-version: 0.2.1
+version: 0.3.0
 synopsis: C++ FFI generator - Standard library bindings
 homepage: http://khumba.net/projects/hoppy
 license: Apache-2.0
@@ -38,7 +38,7 @@
       base >=4.7 && <5
     , filepath >=1.0 && <1.5
     , haskell-src >=1.0 && <1.1
-    , hoppy-generator >=0.2 && <0.3
+    , hoppy-generator >=0.3 && <0.4
   hs-source-dirs: src
   ghc-options: -W -fwarn-incomplete-patterns -fwarn-unused-do-bind
   default-language: Haskell2010
diff --git a/src/Foreign/Hoppy/Generator/Std/Iterator.hs b/src/Foreign/Hoppy/Generator/Std/Iterator.hs
--- a/src/Foreign/Hoppy/Generator/Std/Iterator.hs
+++ b/src/Foreign/Hoppy/Generator/Std/Iterator.hs
@@ -29,6 +29,7 @@
 import Data.Maybe (catMaybes, isJust)
 import Foreign.Hoppy.Generator.Spec (
   Class,
+  ClassFeature (Assignable, Copyable, Equatable),
   MethodApplicability (MNormal),
   Operator (
     OpAdd,
@@ -42,18 +43,14 @@
   Purity (Nonpure),
   Type,
   addReqIncludes,
-  classAddCtors,
-  classAddMethods,
+  classAddEntities,
+  classAddFeatures,
   ident2,
   makeFnMethod,
   mkConstMethod',
   mkCtor,
   mkMethod',
   )
-import Foreign.Hoppy.Generator.Spec.ClassFeature (
-  ClassFeature (Assignable, Copyable, Equatable),
-  classAddFeatures,
-  )
 import Foreign.Hoppy.Generator.Types
 import Foreign.Hoppy.Generator.Std.Internal (includeHelper)
 
@@ -82,14 +79,11 @@
    then addReqIncludes [includeHelper "iterator.hpp"]
    else id) $
   classAddFeatures [Assignable, Copyable, Equatable] $
-  classAddCtors ctors $
-  classAddMethods methods cls
-  where ctors =
-          [ mkCtor "new" []
-          ]
-        methods =
+  classAddEntities ents cls
+  where ents =
           catMaybes
-          [ do valueType <- valueTypeMaybe
+          [ Just $ mkCtor "new" []
+          , do valueType <- valueTypeMaybe
                Mutable <- Just mutable
                return $ mkMethod' OpDeref "get" [] $ refT valueType
           , do valueType <- valueTypeMaybe
@@ -107,9 +101,9 @@
 -- * __operator++:__ @next :: this -> 'refT' ('objT' cls)@.
 makeForwardIterator :: IteratorMutability -> Maybe Type -> Class -> Class
 makeForwardIterator mutable valueTypeMaybe cls =
-  classAddMethods methods $
+  classAddEntities ents $
   makeTrivialIterator mutable valueTypeMaybe cls
-  where methods =
+  where ents =
           [ mkMethod' OpIncPre "next" [] $ refT $ objT cls
           ]
 
@@ -119,9 +113,9 @@
 -- * __operator--:__ @prev :: this -> 'refT' ('objT' cls)@.
 makeBidirectionalIterator :: IteratorMutability -> Maybe Type -> Class -> Class
 makeBidirectionalIterator mutability valueTypeMaybe cls =
-  classAddMethods methods $
+  classAddEntities ents $
   makeForwardIterator mutability valueTypeMaybe cls
-  where methods =
+  where ents =
           [ mkMethod' OpDecPre "prev" [] $ refT $ objT cls
           ]
 
@@ -146,9 +140,9 @@
 -- @valueTypeMaybe@ is present and @mutable@ is 'Mutable'.
 makeRandomIterator :: IteratorMutability -> Maybe Type -> Type -> Class -> Class
 makeRandomIterator mutable valueTypeMaybe distanceType cls =
-  classAddMethods methods $
+  classAddEntities ents $
   makeBidirectionalIterator mutable valueTypeMaybe cls
-  where methods =
+  where ents =
           catMaybes
           [ Just $ mkMethod' OpAdd "plus" [distanceType] $ toGcT $ objT cls
           , Just $ mkMethod' OpAddAssign "add" [distanceType] $ refT $ objT cls
diff --git a/src/Foreign/Hoppy/Generator/Std/List.hs b/src/Foreign/Hoppy/Generator/Std/List.hs
--- a/src/Foreign/Hoppy/Generator/Std/List.hs
+++ b/src/Foreign/Hoppy/Generator/Std/List.hs
@@ -40,13 +40,9 @@
   sayLn,
   saysLn,
   toHsDataTypeName,
-  toHsMethodName',
+  toHsClassEntityName,
   )
 import Foreign.Hoppy.Generator.Spec
-import Foreign.Hoppy.Generator.Spec.ClassFeature (
-  ClassFeature (Assignable, Comparable, Copyable, Equatable),
-  classAddFeatures,
-  )
 import Foreign.Hoppy.Generator.Std (ValueConversion (ConvertPtr, ConvertValue))
 import Foreign.Hoppy.Generator.Std.Iterator
 import Foreign.Hoppy.Generator.Types
@@ -94,11 +90,10 @@
            Just conversion -> addAddendumHaskell $ makeAddendum conversion) $
         addReqs reqs $
         classAddFeatures features $
-        makeClass (ident1T "std" "list" [t]) (Just $ toExtName listName) []
-        [ mkCtor "new" []
-        ] $
+        makeClass (ident1T "std" "list" [t]) (Just $ toExtName listName) [] $
         collect
-        [ just $ mkMethod' "back" "back" [] $ refT t
+        [ just $ mkCtor "new" []
+        , just $ mkMethod' "back" "back" [] $ refT t
         , just $ mkConstMethod' "back" "backConst" [] $ refT $ constT t
         , just $ mkMethod' "begin" "begin" [] $ toGcT $ objT iterator
         , just $ mkConstMethod' "begin" "beginConst" [] $ toGcT $ objT constIterator
@@ -140,7 +135,7 @@
         addReqs reqs $
         makeBidirectionalIterator Mutable (Just t) $
         makeClass (identT' [("std", Nothing), ("list", Just [t]), ("iterator", Nothing)])
-        (Just $ toExtName iteratorName) [] [] []
+        (Just $ toExtName iteratorName) [] []
 
       constIterator =
         addReqs reqs $
@@ -149,8 +144,7 @@
         (Just $ toExtName constIteratorName)
         []
         [ mkCtor "newFromConst" [objT iterator]
-        ]
-        [ makeFnMethod (ident2 "hoppy" "iterator" "deconst") "deconst" MConst Nonpure
+        , makeFnMethod (ident2 "hoppy" "iterator" "deconst") "deconst" MConst Nonpure
           [objT constIterator, refT $ objT list] $ toGcT $ objT iterator
         ]
 
@@ -164,7 +158,7 @@
           addImports $ hsImport1 "Prelude" "(=<<)"
 
         forM_ [Const, Nonconst] $ \cst -> do
-          let hsDataTypeName = toHsDataTypeName cst list
+          hsDataTypeName <- toHsDataTypeName cst list
           hsValueType <-
             cppTypeToHsTypeAndUse HsHsSide $
             (case conversion of
@@ -181,37 +175,41 @@
           indent $ do
             sayLn "toContents this' = do"
             indent $ do
-              let listBegin = case cst of
-                    Const -> "beginConst"
-                    Nonconst -> "begin"
-                  listEnd = case cst of
-                    Const -> "endConst"
-                    Nonconst -> "end"
-                  iter = case cst of
+              listEmpty <- toHsClassEntityName list "empty"
+              listBegin <- toHsClassEntityName list $ case cst of
+                Const -> "beginConst"
+                Nonconst -> "begin"
+              listEnd <- toHsClassEntityName list $ case cst of
+                Const -> "endConst"
+                Nonconst -> "end"
+              let iter = case cst of
                     Const -> constIterator
                     Nonconst -> iterator
-                  iterGet = case cst of
-                    Const -> "getConst"
-                    Nonconst -> "get"
-              saysLn ["empty' <- ", toHsMethodName' list "empty", " this'"]
+              iterEq <- toHsClassEntityName iter OpEq
+              iterGet <- toHsClassEntityName iter $ case cst of
+                Const -> "getConst"
+                Nonconst -> "get"
+              iterPrev <- toHsClassEntityName iter "prev"
+
+              saysLn ["empty' <- ", listEmpty, " this'"]
               sayLn "if empty' then HoppyP.return [] else do"
               indent $ do
-                saysLn ["begin' <- ", toHsMethodName' list listBegin, " this'"]
-                saysLn ["iter' <- ", toHsMethodName' list listEnd, " this'"]
+                saysLn ["begin' <- ", listBegin, " this'"]
+                saysLn ["iter' <- ", listEnd, " this'"]
                 sayLn "go' iter' begin' []"
               sayLn "where"
               indent $ do
                 sayLn "go' iter' begin' acc' = do"
                 indent $ do
-                  saysLn ["stop' <- ", toHsMethodName' iter OpEq, " iter' begin'"]
+                  saysLn ["stop' <- ", iterEq, " iter' begin'"]
                   sayLn "if stop' then HoppyP.return acc' else do"
                   indent $ do
-                    saysLn ["_ <- ", toHsMethodName' iter "prev", " iter'"]
+                    saysLn ["_ <- ", iterPrev, " iter'"]
                     saysLn ["value' <- ",
                             case conversion of
                               ConvertPtr -> ""
                               ConvertValue -> "HoppyFHR.decode =<< ",
-                            toHsMethodName' iter iterGet, " iter'"]
+                            iterGet, " iter'"]
                     sayLn "go' iter' begin' $ value':acc'"
 
           -- Only generate a nonconst FromContents instance.
@@ -222,8 +220,10 @@
             indent $ do
               sayLn "fromContents values' = do"
               indent $ do
-                saysLn ["list' <- ", toHsMethodName' list "new"]
-                saysLn ["HoppyP.mapM_ (", toHsMethodName' list "pushBack", " list') values'"]
+                listNew <- toHsClassEntityName list "new"
+                listPushBack <- toHsClassEntityName list "pushBack"
+                saysLn ["list' <- ", listNew]
+                saysLn ["HoppyP.mapM_ (", listPushBack, " list') values'"]
                 sayLn "HoppyP.return list'"
 
   in Contents
diff --git a/src/Foreign/Hoppy/Generator/Std/Map.hs b/src/Foreign/Hoppy/Generator/Std/Map.hs
--- a/src/Foreign/Hoppy/Generator/Std/Map.hs
+++ b/src/Foreign/Hoppy/Generator/Std/Map.hs
@@ -40,13 +40,9 @@
   sayLn,
   saysLn,
   toHsDataTypeName,
-  toHsMethodName',
+  toHsClassEntityName,
   )
 import Foreign.Hoppy.Generator.Spec
-import Foreign.Hoppy.Generator.Spec.ClassFeature (
-  ClassFeature (Assignable, Copyable),
-  classAddFeatures,
-  )
 import Foreign.Hoppy.Generator.Std (ValueConversion (ConvertPtr, ConvertValue))
 import Foreign.Hoppy.Generator.Std.Internal (includeHelper)
 import Foreign.Hoppy.Generator.Std.Iterator
@@ -111,8 +107,7 @@
         classAddFeatures (Assignable : Copyable : optMapClassFeatures opts) $
         makeClass (ident1T "std" "map" [k, v]) (Just extName) []
         [ mkCtor "new" []
-        ]
-        [ mkMethod' "at" "at" [k] $ refT v
+        , mkMethod' "at" "at" [k] $ refT v
         , mkConstMethod' "at" "atConst" [k] $ refT $ constT v
         , mkMethod' "begin" "begin" [] $ toGcT $ objT iterator
         , mkConstMethod' "begin" "beginConst" [] $ toGcT $ objT constIterator
@@ -142,7 +137,7 @@
         makeClass (identT' [("std", Nothing),
                             ("map", Just [k, v]),
                             ("iterator", Nothing)])
-        (Just $ toExtName iteratorName) [] []
+        (Just $ toExtName iteratorName) []
         [ makeFnMethod getIteratorKeyIdent "getKey" MConst Nonpure
           [objT iterator] $ refT $ constT k
         , makeFnMethod getIteratorValueIdent "getValue" MNormal Nonpure
@@ -160,8 +155,7 @@
         (Just $ toExtName constIteratorName)
         []
         [ mkCtor "newFromConst" [objT iterator]
-        ]
-        [ makeFnMethod (ident2 "hoppy" "iterator" "deconst") "deconst" MConst Nonpure
+        , makeFnMethod (ident2 "hoppy" "iterator" "deconst") "deconst" MConst Nonpure
           [objT constIterator, refT $ objT map] $ toGcT $ objT iterator
         , makeFnMethod getIteratorKeyIdent "getKey" MConst Nonpure
           [objT constIterator] $ refT $ constT k
@@ -177,7 +171,7 @@
                               hsImportForRuntime]
 
         forM_ [Const, Nonconst] $ \cst -> do
-          let hsDataTypeName = toHsDataTypeName cst map
+          hsDataTypeName <- toHsDataTypeName cst map
 
           keyHsType <-
             cppTypeToHsTypeAndUse HsHsSide $
@@ -202,42 +196,47 @@
           indent $ do
             sayLn "toContents this' = do"
             indent $ do
-              let mapBegin = case cst of
-                    Const -> "beginConst"
-                    Nonconst -> "begin"
-                  mapEnd = case cst of
-                    Const -> "endConst"
-                    Nonconst -> "end"
-                  iter = case cst of
+              mapEmpty <- toHsClassEntityName map "empty"
+              mapBegin <- toHsClassEntityName map $ case cst of
+                Const -> "beginConst"
+                Nonconst -> "begin"
+              mapEnd <- toHsClassEntityName map $ case cst of
+                Const -> "endConst"
+                Nonconst -> "end"
+              let iter = case cst of
                     Const -> constIterator
                     Nonconst -> iterator
-                  iterGetValue = case cst of
-                    Const -> "getValueConst"
-                    Nonconst -> "getValue"
-              saysLn ["empty' <- ", toHsMethodName' map "empty", " this'"]
+              iterEq <- toHsClassEntityName iter OpEq
+              iterGetKey <- toHsClassEntityName iter "getKey"
+              iterGetValue <- toHsClassEntityName iter $ case cst of
+                Const -> "getValueConst"
+                Nonconst -> "getValue"
+              iterPrev <- toHsClassEntityName iter "prev"
+
+              saysLn ["empty' <- ", mapEmpty, " this'"]
               sayLn "if empty' then HoppyP.return [] else do"
               indent $ do
-                saysLn ["begin' <- ", toHsMethodName' map mapBegin, " this'"]
-                saysLn ["iter' <- ", toHsMethodName' map mapEnd, " this'"]
+                saysLn ["begin' <- ", mapBegin, " this'"]
+                saysLn ["iter' <- ", mapEnd, " this'"]
                 sayLn "go' iter' begin' []"
               sayLn "where"
               indent $ do
                 sayLn "go' iter' begin' acc' = do"
                 indent $ do
-                  saysLn ["stop' <- ", toHsMethodName' iter OpEq, " iter' begin'"]
+                  saysLn ["stop' <- ", iterEq, " iter' begin'"]
                   sayLn "if stop' then HoppyP.return acc' else do"
                   indent $ do
-                    saysLn ["_ <- ", toHsMethodName' iter "prev", " iter'"]
+                    saysLn ["_ <- ", iterPrev, " iter'"]
                     saysLn ["key' <- ",
                             case keyConv of
                               ConvertPtr -> ""
                               ConvertValue -> "HoppyFHR.decode =<< ",
-                            toHsMethodName' iter "getKey", " iter'"]
+                            iterGetKey, " iter'"]
                     saysLn ["value' <- ",
                             case valueConv of
                               ConvertPtr -> ""
                               ConvertValue -> "HoppyFHR.decode =<< ",
-                            toHsMethodName' iter iterGetValue, " iter'"]
+                            iterGetValue, " iter'"]
                     sayLn "go' iter' begin' $ (key', value'):acc'"
 
           -- Only generate a nonconst FromContents instance.
@@ -248,9 +247,11 @@
             indent $ do
               sayLn "fromContents values' = do"
               indent $ do
-                saysLn ["map' <- ", toHsMethodName' map "new"]
+                mapNew <- toHsClassEntityName map "new"
+                mapAt <- toHsClassEntityName map "at"
+                saysLn ["map' <- ", mapNew]
                 saysLn ["HoppyP.mapM_ (\\(k, v) -> HoppyP.flip HoppyFHR.assign v =<< ",
-                        toHsMethodName' map "at", " map' k) values'"]
+                        mapAt, " map' k) values'"]
                 sayLn "HoppyP.return map'"
 
   in Contents
diff --git a/src/Foreign/Hoppy/Generator/Std/Pair.hs b/src/Foreign/Hoppy/Generator/Std/Pair.hs
--- a/src/Foreign/Hoppy/Generator/Std/Pair.hs
+++ b/src/Foreign/Hoppy/Generator/Std/Pair.hs
@@ -30,10 +30,6 @@
 import Data.Monoid (mconcat)
 #endif
 import Foreign.Hoppy.Generator.Spec
-import Foreign.Hoppy.Generator.Spec.ClassFeature (
-  ClassFeature (Assignable, Copyable),
-  classAddFeatures,
-  )
 import Foreign.Hoppy.Generator.Std.Internal (includeHelper)
 import Foreign.Hoppy.Generator.Types
 import Foreign.Hoppy.Generator.Version (CppVersion (Cpp2011), activeCppVersion, collect, just, test)
@@ -72,12 +68,11 @@
       pair =
         addReqs reqs $
         classAddFeatures (Assignable : Copyable : optPairClassFeatures opts) $
-        makeClass (ident1T "std" "pair" [a, b]) (Just $ toExtName pairName) []
-        [ mkCtor "new" []
-        , mkCtor "newWith" [a, b]
-        ] $
+        makeClass (ident1T "std" "pair" [a, b]) (Just $ toExtName pairName) [] $
         collect
-        [ just $ makeFnMethod (ident2 "hoppy" "utility" "pairFirst") "first" MNormal Nonpure
+        [ just $ mkCtor "new" []
+        , just $ mkCtor "newWith" [a, b]
+        , just $ makeFnMethod (ident2 "hoppy" "utility" "pairFirst") "first" MNormal Nonpure
           [refT $ objT pair] $ refT a
         , just $ makeFnMethod (ident2 "hoppy" "utility" "pairFirst") "firstConst" MConst Nonpure
           [refT $ objT pair] $ refT $ constT a
diff --git a/src/Foreign/Hoppy/Generator/Std/Set.hs b/src/Foreign/Hoppy/Generator/Std/Set.hs
--- a/src/Foreign/Hoppy/Generator/Std/Set.hs
+++ b/src/Foreign/Hoppy/Generator/Std/Set.hs
@@ -41,13 +41,9 @@
   saysLn,
   toHsCastMethodName,
   toHsDataTypeName,
-  toHsMethodName',
+  toHsClassEntityName,
   )
 import Foreign.Hoppy.Generator.Spec
-import Foreign.Hoppy.Generator.Spec.ClassFeature (
-  ClassFeature (Assignable, Comparable, Copyable),
-  classAddFeatures,
-  )
 import Foreign.Hoppy.Generator.Std (ValueConversion (ConvertPtr, ConvertValue))
 import Foreign.Hoppy.Generator.Std.Internal (includeHelper)
 import Foreign.Hoppy.Generator.Std.Iterator
@@ -98,8 +94,7 @@
         classAddFeatures (Assignable : Comparable : Copyable : optSetClassFeatures opts) $
         makeClass (ident1T "std" "set" [t]) (Just $ toExtName setName) []
         [ mkCtor "new" []
-        ]
-        [ mkConstMethod "begin" [] $ toGcT $ objT iterator
+        , mkConstMethod "begin" [] $ toGcT $ objT iterator
         , mkMethod "clear" [] voidT
         , mkConstMethod "count" [t] sizeT
           -- TODO count
@@ -127,7 +122,7 @@
         addReqs reqs $
         makeBidirectionalIterator Constant (Just t) $
         makeClass (identT' [("std", Nothing), ("set", Just [t]), ("iterator", Nothing)])
-        (Just $ toExtName iteratorName) [] [] []
+        (Just $ toExtName iteratorName) [] []
 
       -- The addendum for the set class contains HasContents and FromContents
       -- instances.
@@ -138,8 +133,8 @@
         when (conversion == ConvertValue) $
           addImports $ mconcat [hsImport1 "Prelude" "(=<<)"]
 
-        let hsDataNameConst = toHsDataTypeName Const set
-            hsDataName = toHsDataTypeName Nonconst set
+        hsDataNameConst <- toHsDataTypeName Const set
+        hsDataName <- toHsDataTypeName Nonconst set
         [hsValueTypeConst, hsValueType] <- forM [Const, Nonconst] $ \cst ->
             cppTypeToHsTypeAndUse HsHsSide $
             (case conversion of
@@ -149,6 +144,14 @@
               Const -> constT t
               Nonconst -> t
 
+        setConstCast <- toHsCastMethodName Const set
+        setEmpty <- toHsClassEntityName set "empty"
+        setBegin <- toHsClassEntityName set "begin"
+        setEnd <- toHsClassEntityName set "end"
+        iterEq <- toHsClassEntityName iterator OpEq
+        iterGetConst <- toHsClassEntityName iterator "getConst"
+        iterPrev <- toHsClassEntityName iterator "prev"
+
         -- Generate const and nonconst HasContents instances.
         ln
         saysLn ["instance HoppyFHR.HasContents ", hsDataNameConst,
@@ -156,31 +159,31 @@
         indent $ do
           sayLn "toContents this' = do"
           indent $ do
-            saysLn ["empty' <- ", toHsMethodName' set "empty", " this'"]
+            saysLn ["empty' <- ", setEmpty, " this'"]
             sayLn "if empty' then HoppyP.return [] else do"
             indent $ do
-              saysLn ["begin' <- ", toHsMethodName' set "begin", " this'"]
-              saysLn ["iter' <- ", toHsMethodName' set "end", " this'"]
+              saysLn ["begin' <- ", setBegin, " this'"]
+              saysLn ["iter' <- ", setEnd, " this'"]
               sayLn "go' iter' begin' []"
             sayLn "where"
             indent $ do
               sayLn "go' iter' begin' acc' = do"
               indent $ do
-                saysLn ["stop' <- ", toHsMethodName' iterator OpEq, " iter' begin'"]
+                saysLn ["stop' <- ", iterEq, " iter' begin'"]
                 sayLn "if stop' then HoppyP.return acc' else do"
                 indent $ do
-                  saysLn ["_ <- ", toHsMethodName' iterator "prev", " iter'"]
+                  saysLn ["_ <- ", iterPrev, " iter'"]
                   saysLn ["value' <- ",
                           case conversion of
                             ConvertPtr -> ""
                             ConvertValue -> "HoppyFHR.decode =<< ",
-                          toHsMethodName' iterator "getConst", " iter'"]
+                          iterGetConst, " iter'"]
                   sayLn "go' iter' begin' $ value':acc'"
         ln
         saysLn ["instance HoppyFHR.HasContents ", hsDataName,
                 " (", prettyPrint hsValueTypeConst, ") where"]
         indent $
-          saysLn ["toContents = HoppyFHR.toContents . ", toHsCastMethodName Const set]
+          saysLn ["toContents = HoppyFHR.toContents . ", setConstCast]
 
         -- Only generate a nonconst FromContents instance.
         ln
@@ -189,8 +192,10 @@
         indent $ do
           sayLn "fromContents values' = do"
           indent $ do
-            saysLn ["set' <- ", toHsMethodName' set "new"]
-            saysLn ["HoppyP.mapM_ (", toHsMethodName' set "insert", " set') values'"]
+            setNew <- toHsClassEntityName set "new"
+            setInsert <- toHsClassEntityName set "insert"
+            saysLn ["set' <- ", setNew]
+            saysLn ["HoppyP.mapM_ (", setInsert, " set') values'"]
             sayLn "HoppyP.return set'"
 
   in Contents
diff --git a/src/Foreign/Hoppy/Generator/Std/String.hs b/src/Foreign/Hoppy/Generator/Std/String.hs
--- a/src/Foreign/Hoppy/Generator/Std/String.hs
+++ b/src/Foreign/Hoppy/Generator/Std/String.hs
@@ -24,7 +24,6 @@
 #endif
 import Foreign.Hoppy.Generator.Language.Haskell (addImports, sayLn)
 import Foreign.Hoppy.Generator.Spec
-import Foreign.Hoppy.Generator.Spec.ClassFeature
 import Foreign.Hoppy.Generator.Types
 import Language.Haskell.Syntax (
   HsName (HsIdent),
@@ -39,22 +38,20 @@
   classAddFeatures [Assignable, Comparable, Copyable, Equatable] $
   classSetHaskellConversion
     ClassHaskellConversion
-      { classHaskellConversionType = do
+      { classHaskellConversionType = Just $ do
         addImports hsImportForPrelude
         return $ HsTyCon $ UnQual $ HsIdent "HoppyP.String"
-      , classHaskellConversionToCppFn = do
+      , classHaskellConversionToCppFn = Just $ do
         addImports $ mconcat [hsImportForPrelude, hsImportForForeignC]
         sayLn "HoppyP.flip HoppyFC.withCString stdString_newFromCString"
-      , classHaskellConversionFromCppFn = do
+      , classHaskellConversionFromCppFn = Just $ do
         addImports $ mconcat [hsImport1 "Control.Monad" "(<=<)", hsImportForForeignC]
         sayLn "HoppyFC.peekCString <=< stdString_c_str"
       } $
-  makeClass (ident1 "std" "string") (Just $ toExtName "StdString")
-  []
+  makeClass (ident1 "std" "string") (Just $ toExtName "StdString") []
   [ mkCtor "new" []
   , mkCtor "newFromCString" [ptrT $ constT charT]
-  ]
-  [ mkConstMethod' "at" "at" [intT] $ refT charT
+  , mkConstMethod' "at" "at" [intT] $ refT charT
   , mkConstMethod' "at" "get" [intT] charT
   , mkConstMethod "c_str" [] $ ptrT $ constT charT
   , mkConstMethod "size" [] sizeT
diff --git a/src/Foreign/Hoppy/Generator/Std/Vector.hs b/src/Foreign/Hoppy/Generator/Std/Vector.hs
--- a/src/Foreign/Hoppy/Generator/Std/Vector.hs
+++ b/src/Foreign/Hoppy/Generator/Std/Vector.hs
@@ -40,13 +40,9 @@
   sayLn,
   saysLn,
   toHsDataTypeName,
-  toHsMethodName',
+  toHsClassEntityName,
   )
 import Foreign.Hoppy.Generator.Spec
-import Foreign.Hoppy.Generator.Spec.ClassFeature (
-  ClassFeature (Assignable, Copyable),
-  classAddFeatures,
-  )
 import Foreign.Hoppy.Generator.Std (ValueConversion (ConvertPtr, ConvertValue))
 import Foreign.Hoppy.Generator.Std.Iterator
 import Foreign.Hoppy.Generator.Types
@@ -95,11 +91,10 @@
            Just conversion -> addAddendumHaskell $ makeAddendum conversion) $
         addReqs reqs $
         classAddFeatures (Assignable : Copyable : optVectorClassFeatures opts) $
-        makeClass (ident1T "std" "vector" [t]) (Just $ toExtName vectorName) []
-        [ mkCtor "new" []
-        ] $
+        makeClass (ident1T "std" "vector" [t]) (Just $ toExtName vectorName) [] $
         collect
-        [ just $ mkMethod' "at" "at" [sizeT] $ refT t
+        [ just $ mkCtor "new" []
+        , just $ mkMethod' "at" "at" [sizeT] $ refT t
         , just $ mkConstMethod' "at" "atConst" [sizeT] $ refT $ constT t
         , just $ mkMethod' "back" "back" [] $ refT t
         , just $ mkConstMethod' "back" "backConst" [] $ refT $ constT t
@@ -130,7 +125,7 @@
         addReqs reqs $
         makeRandomIterator Mutable (Just t) ptrdiffT $
         makeClass (identT' [("std", Nothing), ("vector", Just [t]), ("iterator", Nothing)])
-        (Just $ toExtName iteratorName) [] [] []
+        (Just $ toExtName iteratorName) [] []
 
       constIterator =
         addReqs reqs $
@@ -138,8 +133,7 @@
         makeClass (identT' [("std", Nothing), ("vector", Just [t]), ("const_iterator", Nothing)])
         (Just $ toExtName constIteratorName) []
         [ mkCtor "newFromNonconst" [objT iterator]
-        ]
-        [ makeFnMethod (ident2 "hoppy" "iterator" "deconst") "deconst" MConst Nonpure
+        , makeFnMethod (ident2 "hoppy" "iterator" "deconst") "deconst" MConst Nonpure
           [objT constIterator, refT $ objT vector] $ toGcT $ objT iterator
         ]
 
@@ -153,7 +147,7 @@
           addImports $ hsImport1 "Control.Monad" "(<=<)"
 
         forM_ [Const, Nonconst] $ \cst -> do
-          let hsDataTypeName = toHsDataTypeName cst vector
+          hsDataTypeName <- toHsDataTypeName cst vector
           hsValueType <-
             cppTypeToHsTypeAndUse HsHsSide $
             (case conversion of
@@ -170,15 +164,17 @@
           indent $ do
             sayLn "toContents this' = do"
             indent $ do
-              let vectorAt = case cst of
-                    Const -> "atConst"
-                    Nonconst -> "at"
-              saysLn ["size' <- ", toHsMethodName' vector "size", " this'"]
+              vectorAt <- toHsClassEntityName vector $ case cst of
+                Const -> "atConst"
+                Nonconst -> "at"
+              vectorSize <- toHsClassEntityName vector "size"
+
+              saysLn ["size' <- ", vectorSize, " this'"]
               saysLn ["HoppyP.mapM (",
                       case conversion of
                         ConvertPtr -> ""
                         ConvertValue -> "HoppyFHR.decode <=< ",
-                      toHsMethodName' vector vectorAt, " this') [0..size'-1]"]
+                      vectorAt, " this') [0..size'-1]"]
 
           -- Only generate a nonconst FromContents instance.
           when (cst == Nonconst) $ do
@@ -188,10 +184,12 @@
             indent $ do
               sayLn "fromContents values' = do"
               indent $ do
-                saysLn ["vector' <- ", toHsMethodName' vector "new"]
-                saysLn [toHsMethodName' vector "reserve",
-                        " vector' $ HoppyFHR.coerceIntegral $ HoppyP.length values'"]
-                saysLn ["HoppyP.mapM_ (", toHsMethodName' vector "pushBack", " vector') values'"]
+                vectorNew <- toHsClassEntityName vector "new"
+                vectorPushBack <- toHsClassEntityName vector "pushBack"
+                vectorReserve <- toHsClassEntityName vector "reserve"
+                saysLn ["vector' <- ", vectorNew]
+                saysLn [vectorReserve, " vector' $ HoppyFHR.coerceIntegral $ HoppyP.length values'"]
+                saysLn ["HoppyP.mapM_ (", vectorPushBack, " vector') values'"]
                 sayLn "HoppyP.return vector'"
 
   in Contents