This seems like a good idea, but as a generic interface, this seems
suboptimal.  In particular, it seems odd that a parsing function would
have to know about a process and require the caller to set up various
process properties and buffer-local variables.  What about something
dedicated to incrementally parsing lists, like the async parser but
more specialized?  Something along the lines of,

(defun notmuch-json-parse-partial-list (result-function error-function 
					&optional buffer)
  "Parse a partial JSON list from BUFFER (or the current buffer).

This function consumes a JSON list from BUFFER, applying
RESULT-FUNCTION to each complete value in the list.  It operates
incrementally and should be called whenever the buffer has been
extended with additional data.

If there is a syntax error, this will attempt to resynchronize with
the input and will apply ERROR-FUNCTION to any input that was
skipped.

This calls RESULT-FUNCTION and ERROR-FUNCTION with the same current
buffer as this function is called with (that is, this function does
not visibly switch to BUFFER)."
  ...)

This could use buffer-local variables for tracking the async parser
state as well its own state.  It could even set these up automatically
when called for the first time in a buffer without them set, making it
very DWIM.  It would clearly require a little more help from the
caller for process management than your patch does (and a little less
for parser setup), but I think the genericity would be worth it.

Quoth Mark Walters on Jul 28 at 12:48 pm:
> 
> We separate out the json parser into its own function. 
> ---
> 
> Hi
> 
> Notmuch pick uses the new asynchronous json parser and the code to do so
> is almost identical to that for the search mode. Thus separate out the
> parsing in search mode into a more general function that can easily be
> used by both pick and search.
> 
> This saves nearly 50 lines of duplicated code in notmuch-pick.el.
> 
> The function notmuch-json-async-parse should probably be move in
> notmuch-lib but that can be a follow on patch.
> 
> Best wishes
> 
> Mark
> 
>  emacs/notmuch.el |   46 ++++++++++++++++++++++++++++++++++++----------
>  1 files changed, 36 insertions(+), 10 deletions(-)
> 
> diff --git a/emacs/notmuch.el b/emacs/notmuch.el
> index fd1836f..ee01028 100644
> --- a/emacs/notmuch.el
> +++ b/emacs/notmuch.el
> @@ -816,7 +816,32 @@ non-authors is found, assume that all of the authors match."
>    "Incremental JSON parser for the search process filter.")
>  
>  (defun notmuch-search-process-filter (proc string)
> -  "Process and filter the output of \"notmuch search\""
> +  "Process and filter the output of  \"notmuch search\" using the asynchronous parser."
> +  (setq notmuch-search-process-state
> +	(notmuch-json-async-parse proc
> +				  string
> +				  notmuch-search-process-state
> +				  notmuch-search-json-parser
> +				  'notmuch-search-show-result
> +				  'notmuch-search-show-error)))
> +
> +(defun notmuch-json-async-parse (proc string process-state parser result-function error-function)
> +  "Process and filter the output using the asynchronous parser.
> +
> +This function steps into the first level of JSON nesting and then
> +applies RESULT-FUNCTION to each complete JSON object as it comes
> +in.
> +
> +PROC is the process: it should have a results buffer as
> +process-buffer and a 'parse-buf for the incoming json.
> +PROCESS-STATE the current state of filter process
> +STRING the incoming data
> +PARSER the parser
> +RESULT-FUNCTION a function to call on complete pieces of json
> +ERROR-FUNCTION the function to call on errors
> +
> +The function returns the new PROCESS-STATE"
> +
>    (let ((results-buf (process-buffer proc))
>  	(parse-buf (process-get proc 'parse-buf))
>  	(inhibit-read-only t)
> @@ -831,28 +856,28 @@ non-authors is found, assume that all of the authors match."
>        (with-current-buffer results-buf
>  	(while (not done)
>  	  (condition-case nil
> -	      (case notmuch-search-process-state
> +	      (case process-state
>  		((begin)
>  		 ;; Enter the results list
>  		 (if (eq (notmuch-json-begin-compound
> -			  notmuch-search-json-parser) 'retry)
> +			  parser) 'retry)
>  		     (setq done t)
> -		   (setq notmuch-search-process-state 'result)))
> +		   (setq process-state 'result)))
>  		((result)
>  		 ;; Parse a result
> -		 (let ((result (notmuch-json-read notmuch-search-json-parser)))
> +		 (let ((result (notmuch-json-read parser)))
>  		   (case result
>  		     ((retry) (setq done t))
> -		     ((end) (setq notmuch-search-process-state 'end))
> -		     (otherwise (notmuch-search-show-result result)))))
> +		     ((end) (setq process-state 'end))
> +		     (otherwise (funcall result-function result)))))
>  		((end)
>  		 ;; Any trailing data is unexpected
> -		 (notmuch-json-eof notmuch-search-json-parser)
> +		 (notmuch-json-eof parser)
>  		 (setq done t)))
>  	    (json-error
>  	     ;; Do our best to resynchronize and ensure forward
>  	     ;; progress
> -	     (notmuch-search-show-error
> +	     (funcall error-function
>  	      "%s"
>  	      (with-current-buffer parse-buf
>  		(let ((bad (buffer-substring (line-beginning-position)
> @@ -861,7 +886,8 @@ non-authors is found, assume that all of the authors match."
>  		  bad))))))
>  	;; Clear out what we've parsed
>  	(with-current-buffer parse-buf
> -	  (delete-region (point-min) (point)))))))
> +	  (delete-region (point-min) (point))))
> +      process-state)))
>  
>  (defun notmuch-search-tag-all (&optional tag-changes)
>    "Add/remove tags from all messages in current search buffer.