anchor.diff:  typedef Future RetryStrategy(int retryCount);
   
   Future<bool> retryImmediately(int retryCount) => new Future.value(true);
  +
  +typedef void StreamyRpcRetryFn();
  +
  +class StreamyRpcException implements Exception {
  +  final int httpStatus;
  +  final Request request;
  +  bool get retryable => false;
  +  final List<Map> errors;
  +  Map get error => errors[0];
  +  
  +  StreamyRpcException._private(this.httpStatus, this.request, this.errors);
  +}
  +
  +class StreamyRetryableRpcException extends StreamyRpcException {
  +  
  +  final int retryCount;
  +  final StreamyRpcExceptionRetryFn retry;
  +  
  +  bool get retryable => true;
  +  
  +  StreamyRetryableRpcException._wrap(StreamyRpcException e, this.retryCount, this.retry) : super(e.httpStatus, e.request, e.errors)
  +  
  +
  +class NotRetryableException implements Exception {
  +  toString() => "[notRetryable: Streamy request is not retryable]";
  +}
   
   class RetryingRequestHandler extends RequestHandler {
     
  
positive.code:     
      return doRpc().asStream();
    }
  }
  
negative.code:           }
            // We need to retry. retryFuture is a future that doesn't return a value, but indicates when
            // the call should be retried.
            var retryFuture = strategy(request, ++retry, e);
            if (retry > maxRetries) {
              // Time to give up.
              throw e;
  