diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,3 +1,8 @@
+## 0.4.0.0
+
+* Add type VaArgs for non-parenthesized variable-length list of parameters.
+* Include fieldName in other constructors of ResultError.
+
 ## 0.3.0.0
 
 * New maintainer and GitHub location - with many thanks to Bryan O'Sullivan for all of the past work on this module, and for facilitating the transfer of maintenance responsibility.
diff --git a/Database/MySQL/Simple.hs b/Database/MySQL/Simple.hs
--- a/Database/MySQL/Simple.hs
+++ b/Database/MySQL/Simple.hs
@@ -48,6 +48,7 @@
     , Connection
     , Query
     , In(..)
+    , VaArgs(..)
     , Binary(..)
     , Only(..)
     -- ** Exceptions
@@ -97,7 +98,7 @@
 import Database.MySQL.Simple.QueryParams (QueryParams(..))
 import Database.MySQL.Simple.QueryResults (QueryResults(..))
 import Database.MySQL.Simple.Result (ResultError(..))
-import Database.MySQL.Simple.Types (Binary(..), In(..), Only(..), Query(..))
+import Database.MySQL.Simple.Types (Binary(..), In(..), VaArgs(..), Only(..), Query(..))
 import Text.Regex.PCRE.Light (compile, caseless, match)
 import qualified Data.ByteString.Char8 as B
 import qualified Database.MySQL.Base as Base
@@ -617,7 +618,7 @@
 --   For instance, you can always extract a MySQL @TINYINT@ column to
 --   a Haskell 'Int'.  The Haskell 'Float' type can accurately
 --   represent MySQL integer types of size up to @INT24@, so it is
---   considered compatble with those types.
+--   considered compatible with those types.
 --
 -- * A numeric compatibility check is based only on the type of a
 --   column, /not/ on its values. For instance, a MySQL @LONG_LONG@
diff --git a/Database/MySQL/Simple/Param.hs b/Database/MySQL/Simple/Param.hs
--- a/Database/MySQL/Simple/Param.hs
+++ b/Database/MySQL/Simple/Param.hs
@@ -34,7 +34,7 @@
 import Data.Time.LocalTime (TimeOfDay)
 import Data.Typeable (Typeable)
 import Data.Word (Word, Word8, Word16, Word32, Word64)
-import Database.MySQL.Simple.Types (Binary(..), In(..), Null)
+import Database.MySQL.Simple.Types (Binary(..), In(..), VaArgs(..), Null)
 import qualified Blaze.ByteString.Builder.Char.Utf8 as Utf8
 import qualified Data.ByteString as SB
 import qualified Data.ByteString.Lazy as LB
@@ -88,6 +88,11 @@
         Plain (fromChar '(') :
         (intersperse (Plain (fromChar ',')) . map render $ xs) ++
         [Plain (fromChar ')')]
+
+instance (Param a) => Param (VaArgs [a]) where
+    render (VaArgs []) = Plain $ fromByteString "null"
+    render (VaArgs xs) = Many $
+        intersperse (Plain (fromChar ',')) . map render $ xs
 
 instance Param (Binary SB.ByteString) where
     render (Binary bs) = Plain $ fromByteString "x'" `mappend`
diff --git a/Database/MySQL/Simple/QueryResults.hs b/Database/MySQL/Simple/QueryResults.hs
--- a/Database/MySQL/Simple/QueryResults.hs
+++ b/Database/MySQL/Simple/QueryResults.hs
@@ -23,7 +23,7 @@
 import Control.Exception (throw)
 import Data.ByteString (ByteString)
 import qualified Data.ByteString.Char8 as B
-import Database.MySQL.Base.Types (Field(fieldType))
+import Database.MySQL.Base.Types (Field(fieldType, fieldName))
 import Database.MySQL.Simple.Result (ResultError(..), Result(..))
 import Database.MySQL.Simple.Types (Only(..))
 
@@ -357,6 +357,7 @@
     (show (length fs) ++ " values: " ++ show (zip (map fieldType fs)
                                                   (map (fmap ellipsis) vs)))
     (show n ++ " slots in target type")
+    (show (map (B.unpack . fieldName) fs))
     "mismatch between number of columns to convert and number in target type"
 
 ellipsis :: ByteString -> ByteString
diff --git a/Database/MySQL/Simple/Result.hs b/Database/MySQL/Simple/Result.hs
--- a/Database/MySQL/Simple/Result.hs
+++ b/Database/MySQL/Simple/Result.hs
@@ -66,11 +66,13 @@
                  -- ^ The SQL and Haskell types are not compatible.
                  | UnexpectedNull { errSQLType :: String
                                   , errHaskellType :: String
+                                  , errFieldName :: String
                                   , errMessage :: String }
                  -- ^ A SQL @NULL@ was encountered when the Haskell
                  -- type did not permit it.
                  | ConversionFailed { errSQLType :: String
                                     , errHaskellType :: String
+                                    , errFieldName :: String
                                     , errMessage :: String }
                  -- ^ The SQL value could not be parsed, or could not
                  -- be represented as a valid Haskell value, or an
@@ -219,7 +221,8 @@
     | mkCompat (fieldType f) `compat` types = cvt bs
     | otherwise = incompatible f (typeOf (cvt undefined)) "types incompatible"
 doConvert f _ cvt _ = throw $ UnexpectedNull (show (fieldType f))
-                              (show (typeOf (cvt undefined))) ""
+                              (show (typeOf (cvt undefined)))
+                              (B8.unpack (fieldName f)) ""
 
 incompatible :: Field -> TypeRep -> String -> a
 incompatible f r = throw . Incompatible (show (fieldType f))
@@ -228,6 +231,7 @@
 
 conversionFailed :: Field -> String -> String -> a
 conversionFailed f s = throw . ConversionFailed (show (fieldType f)) s
+                                 (B8.unpack (fieldName f))
 
 atto :: (Typeable a) => Compat -> Parser a -> Field -> Maybe ByteString -> a
 atto types p0 f = doConvert f types $ go undefined p0
diff --git a/Database/MySQL/Simple/Types.hs b/Database/MySQL/Simple/Types.hs
--- a/Database/MySQL/Simple/Types.hs
+++ b/Database/MySQL/Simple/Types.hs
@@ -15,6 +15,7 @@
       Null(..)
     , Only(..)
     , In(..)
+    , VaArgs(..)
     , Binary(..)
     , Query(..)
     ) where
@@ -99,6 +100,18 @@
 -- > query c "select * from whatever where id in ?" (Only (In [3,4,5]))
 newtype In a = In a
     deriving (Eq, Ord, Read, Show, Typeable, Functor)
+
+-- | Wrap a list of values for use in a function with variable arguments.
+-- Replaces a single \"@?@\" character with a non-parenthesized list of
+-- rendered values.
+--
+-- Example:
+--
+-- > query conn
+-- >   "SELECT * FROM example_table ORDER BY field(f,?)"
+-- >   (Only (VaArgs [3,2,1]))
+newtype VaArgs a = VaArgs a
+  deriving (Eq, Ord, Read, Show, Typeable, Functor)
 
 -- | Wrap a mostly-binary string to be escaped in hexadecimal.
 newtype Binary a = Binary a
diff --git a/mysql-simple.cabal b/mysql-simple.cabal
--- a/mysql-simple.cabal
+++ b/mysql-simple.cabal
@@ -1,5 +1,5 @@
 name:           mysql-simple
-version:        0.3.0.0
+version:        0.4.0.0
 homepage:       https://github.com/paul-rouse/mysql-simple
 bug-reports:    https://github.com/paul-rouse/mysql-simple/issues
 synopsis:       A mid-level MySQL client library.
@@ -25,6 +25,7 @@
 extra-source-files:
     ChangeLog.md
     README.markdown
+    stack.yaml
 
 flag developer
   description: operate in developer mode
diff --git a/stack.yaml b/stack.yaml
new file mode 100644
--- /dev/null
+++ b/stack.yaml
@@ -0,0 +1,7 @@
+flags:
+  mysql-simple:
+    developer: false
+packages:
+- '.'
+extra-deps: []
+resolver: lts-6.23