restore previous evalaute_impl in calculator example

Naively using async/await open the possibility of double borrows,
as pointed out by clippy.

Author: dwrensha

capnp-rpc/examples/calculator/server.rs

@@ -22,16 +22,17 @@
 use std::cell::RefCell;
 
 use ::capnp::message::HeapAllocator;
+use capnp::capability::Promise;
 use capnp::primitive_list;
 use capnp::Error;
 
 use ::capnp_rpc::ImbuedMessageBuilder;
-use capnp_rpc::{rpc_twoparty_capnp, twoparty, RpcSystem};
+use capnp_rpc::{pry, rpc_twoparty_capnp, twoparty, RpcSystem};
 
 use crate::calculator_capnp::calculator;
 
 use futures::future;
-use futures::{AsyncReadExt, TryFutureExt};
+use futures::{AsyncReadExt, FutureExt, TryFutureExt};
 
 struct ValueImpl {
     value: f64,
@@ -54,31 +55,43 @@ impl calculator::value::Server for ValueImpl {
     }
 }
 
-async fn evaluate_impl(
+fn evaluate_impl(
     expression: calculator::expression::Reader<'_>,
     params: Option<primitive_list::Reader<'_, f64>>,
-) -> Result<f64, Error> {
-    match expression.which()? {
-        calculator::expression::Literal(v) => Ok(v),
-        calculator::expression::PreviousResult(p) => {
-            let v = p?.read_request().send().promise.await?;
-            Ok(v.get()?.get_value())
-        }
+) -> Promise<f64, Error> {
+    match pry!(expression.which()) {
+        calculator::expression::Literal(v) => Promise::ok(v),
+        calculator::expression::PreviousResult(p) => Promise::from_future(
+            pry!(p)
+                .read_request()
+                .send()
+                .promise
+                .map(|v| Ok(v?.get()?.get_value())),
+        ),
+
         calculator::expression::Parameter(p) => match params {
-            Some(params) if p < params.len() => Ok(params.get(p)),
-            _ => Err(Error::failed(format!("bad parameter: {p}"))),
+            Some(params) if p < params.len() => Promise::ok(params.get(p)),
+            _ => Promise::err(Error::failed(format!("bad parameter: {p}"))),
         },
+
         calculator::expression::Call(call) => {
-            let func = call.get_function()?;
-            let eval_params =
-                future::try_join_all(call.get_params()?.iter().map(|p| evaluate_impl(p, params)));
-            let param_values = eval_params.await?;
-            let mut request = func.call_request();
-            let mut params = request.get().init_params(param_values.len() as u32);
-            for (ii, value) in param_values.iter().enumerate() {
-                params.set(ii as u32, *value);
-            }
-            Ok(request.send().promise.await?.get()?.get_value())
+            let func = pry!(call.get_function());
+            let eval_params = future::try_join_all(
+                pry!(call.get_params())
+                    .iter()
+                    .map(|p| evaluate_impl(p, params)),
+            );
+            Promise::from_future(async move {
+                let param_values = eval_params.await?;
+                let mut request = func.call_request();
+                {
+                    let mut params = request.get().init_params(param_values.len() as u32);
+                    for (ii, value) in param_values.iter().enumerate() {
+                        params.set(ii as u32, *value);
+                    }
+                }
+                Ok(request.send().promise.await?.get()?.get_value())
+            })
         }
     }
 }
@@ -120,10 +133,9 @@ impl calculator::function::Server for FunctionImpl {
                 .get_root::<calculator::expression::Builder>()?
                 .into_reader(),
             Some(params),
-        )
-        .await?;
+        );
 
-        results.get().set_value(eval);
+        results.get().set_value(eval.await?);
         Ok(())
     }
 }