1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
//! Definition of the `Result` (immediately finished) combinator use std::{ future::Future, pin::Pin, task::{self, Poll}, }; use crate::{actor::Actor, fut::ActorFuture}; // TODO: remove re-export and encourage direct usage of std and/or futures crate types. pub use futures_util::future::{ready, Ready}; /// Creates a new "leaf future" which will resolve with the given result. /// /// The returned future represents a computation which is finished immediately. /// This can be useful with the `finished` and `failed` base future types to /// convert an immediate value to a future to interoperate elsewhere. /// /// # Examples /// /// ``` /// use actix::{fut, Actor, Context}; /// /// struct MyActor; /// impl Actor for MyActor { /// type Context = Context<Self>; /// } /// /// let future_of_1 = fut::result::<u32, u32>(Ok(1)); /// let future_of_err_2 = fut::result::<u32, u32>(Err(2)); /// ``` pub fn result<T, E>(r: Result<T, E>) -> Ready<Result<T, E>> { ready(r) } /// Creates a "leaf future" from an immediate value of a finished and /// successful computation. /// /// The returned future is similar to `result` where it will immediately run a /// scheduled callback with the provided value. /// /// # Examples /// /// ``` /// use actix::fut::*; /// use actix::{Actor, Context}; /// /// struct MyActor; /// impl Actor for MyActor { /// type Context = Context<Self>; /// } /// /// let future_of_1 = ok::<u32, u32>(1); /// ``` pub fn ok<T, E>(t: T) -> Ready<Result<T, E>> { ready(Ok(t)) } /// Creates a "leaf future" from an immediate value of a failed computation. /// /// The returned future is similar to `result` where it will immediately run a /// scheduled callback with the provided value. /// /// # Examples /// /// ``` /// use actix::{fut, Actor, Context}; /// /// struct MyActor; /// impl Actor for MyActor { /// type Context = Context<Self>; /// } /// /// let future_of_err_1 = fut::err::<u32, u32>(1); /// ``` pub fn err<T, E>(e: E) -> Ready<Result<T, E>> { ready(Err(e)) } impl<T, A> ActorFuture<A> for Ready<T> where A: Actor, { type Output = T; #[inline] fn poll( self: Pin<&mut Self>, _: &mut A, _: &mut A::Context, cx: &mut task::Context<'_>, ) -> Poll<Self::Output> { Future::poll(self, cx) } }