I have written some code which I think would benefit from re-binding.  Here's an example from an (unreleased) Snap application:

``` haskell
queryNoteComments :: Int -> H [Comment]
queryNoteComments nid =
  query "SELECT id,descr,saved_on,color FROM comments WHERE note_id = ?" (Only nid)

queryNotes :: User -> H [Note]
queryNotes user = do
  notes <- query "SELECT id,handle FROM notes WHERE user_id = ?" (Only (uId user))
  mapM queryComments notes
  where
    -- TODO I suppose this really should be a JOIN instead of querying
    -- once for each note.  But probably not a big deal for now..
    queryComments (ni, nh) = do
      comments <- queryNoteComments ni
      return (Note ni nh comments)
```

If this was written using `withStatement`, we could parse & compile the SQL statement in `queryNoteComments` only once instead of repeating the same for each iteration of the `mapM` in `queryNotes`.  I think this may have a perf impact in apps that rely on SQLite for their application data.  I didn't measure this though, so to some extent this is handwaving.

How unsafe would explicit bind be?  In the case when you bind only once, and you have bound params in your SQL statement, you should get an error immediately when step is first called..  This should happen as you're running on a newly created sqlite3_stmt which doesn't yet have any bound parameters.  withBind also checks that statement's # of params matches what were given.