I don't think there's any disagreement about the `with` style combinators.  Connections are already managed using `open` and `close`, plus a  `withConnection` helper contributed by @Emm.   The remaining point of debate (at least to me) is whether `openStatement` should bind parameters or not.  My opinion is that it should not - as explained in my comment https://github.com/nurpax/sqlite-simple/pull/22/files#r2554608.

Here's what I'd propose:

``` haskell
openStatement :: Connection -> Query -> IO Base.Statement
closeStatement :: Base.Statement -> IO ()
withStatement :: Connection -> Query -> (Base.Statement -> IO r) -> IO r
bind :: (ToRow params) => Statement -> params -> IO ()
reset :: Statement -> IO ()  -- just punts to Base.reset
```

Only `bind` would specify bound parameters.  To bind parameters when executing a query with an explicit `Statement` (with `openStatement`, `closeStatement`, `withStatement`), the usage pattern would be:

```
bind [params]
step / nextRow
step / nextRow
...
step / nextRow
reset

bind [params]
step / nextRow
step / nextRow
...
step / nextRow
```

I think this API can be used to implement the various iteratee-style patterns.  Granted it's a little bit low-level and doesn't do everything automatically, but if your use-case needs tighter control over statements, then perhaps the user is also prepared to whip up his own, safer helpers for his use?

To safely use the above statement primitives, I would also add (and I add these in a separate patch if we settle on the basic primitives first):

``` haskell
pquery :: (ToRow q, FromRow r) => Statement -> Query -> q -> IO [r]
-- + same forpquery_, pexecute_, pexecute
```

pquery would perform bind+reset automatically.  In normal cases, this could be used for extra perf when you have a need to execute the same query multiple times, with changing parameters, like in my example:

```
comments <- withStatement "SELECT * FROM comments WHERE id = ?" $ \stmt ->
   mapM_ (\id -> pquery stmt  (Only id)) list_of_some_ids_here
```

As for the performance of this usage pattern, see e.g. http://stackoverflow.com/questions/1711631/how-do-i-improve-the-performance-of-sqlite, section "Using a Prepared Statement".  It documents a significant performance improvement in a case which needs a lot of small INSERTs and needs to compile SQL on each such insert.