Handle responses and options with `chain-` operators

[hugoclrd]

Context

With match <response> or match <optional>, a common pattern is to handle the ok or some value if any, but to return the err or none otherwise.

(match (contract-call? ...)
  response (handle response)
  error-code (err error) ;; simply forward the error
)

(match (map-get? ...)
  value (handle value)
  none ;; forward the none
)

Potential solution(s)

(chain_ok <response> ...handlers), (chain_some <optional> ...handlers)

Inspired by Rust's <result>.map(), or .and_then(), Clarity could have similar helpers.

I suggest the chain- helpers that would accept a response or optional as a first argument, followed by 1 to N function calls or lambdas (#56) to handle and forward the response or optional

(chain-ok (contract-call? .contract get-response) ;; the contract-call returns (response _  uint)
  (handle-ok-0) ;; must return (response _  uint)
  (handle-ok-1) ;; must return (response _  uint)
  ;; variadic number of handlers/lambdas
  (lamdba (x int) (ok (+ x 1))
) 

(chain (map-get? <key>)
  (handle-if-some) ;; must return (optional _)
   ;; variadic number of handlers/lambdas
  (lamdba (x int) (some (+ x 1))
) 

Idea: we could also have a chain-err helper to catch an error and forward another one.

Generic chain

Just like (match response|optional), we could have a generic `(chain response|optional)

Real world examples

// To do

[jbencin]

I've been using let statements to do something like this:

(let ((tmp1 (try! (some-function my-var)))
      (tmp2 (try! (another-function tmp1)))
      (result (try! (last-function tmp2))))

But it would be nice to have something cleaner and without the intermediate variables

[hugoclrd]

Right, let can help, but it makes the intention less clear, and I think that it moves the problem upstream in the handler functions.

(define-private (handle-if-ok (res (response int uint)))
  (match res
     val (ok (+ 1 val))
     error-code (err error-code)
  )
)

;; `my-var` is `(response int uint))`
(let ((result (try! (handle-if-ok my-var)))) result)

vs

(define-private (handle-if-ok (val int))
  (ok (+ 1 val))
)

(chain-ok my-var handle-if-ok)

;; alternatively, with a lambda
(chain-ok my-var
  (lambda (val int) (ok (+ 1 val)))
)