Struct Memo 

pub struct Memo { /* private fields */ }

A view onto a MemoStore scoped to a (run_id, step_number) pair, or to a run as a whole.

Implementations

impl Memo

pub fn run_id(&self) -> &RunId

The run identifier this memo is bound to.

pub fn step_number(&self) -> Option<u32>

The step number this memo is bound to; None for a run-scoped memo.

pub async fn get(&self, key: &str) -> Result<Option<Vec<u8>>>

Read a previously stored value for key, or Ok(None) if none has been written.

pub async fn put(&self, key: &str, value: &[u8]) -> Result<()>

Store value for key, overwriting any prior value.

Overwrite is intentional: a retry that produces the same value is idempotent. A retry that produces a different value indicates the handler isn’t perfectly idempotent; the memo reflects whatever the most recent attempt wrote.

pub async fn memoized<R, F, E>(&self, key: &str, compute: F) -> Result<R, E>

where R: Serialize + DeserializeOwned, F: Future<Output = Result<R, E>>, E: From<Error>,

Return the value stored under key, or run compute, store its value under key and return it.

The value is encoded as MessagePack with named fields. An entry that fails to decode as R is treated as absent: compute runs and its value overwrites the entry. An error from compute is returned without storing anything, so a later call runs compute again.

A side effect inside compute runs again when the process terminates after compute returns and before the value is stored.

pub async fn memoized_by_content<K, R, F, E>( &self, input: &K, compute: F, ) -> Result<R, E>

where K: Serialize + ?Sized, R: Serialize + DeserializeOwned, F: Future<Output = Result<R, E>>, E: From<Error>,

Self::memoized under Self::content_key of input.

pub fn content_key<T>(input: &T) -> Result<String>

where T: Serialize + ?Sized,

Derive the memo key for a content-addressed entry: content: followed by the hex SHA-256 digest of input encoded as MessagePack with named fields.

The key is stable only when input serializes deterministically; types with unordered iteration, such as HashMap, can serialize the same logical content into different bytes and therefore different keys. If several logical operations may receive identical inputs, include an operation name in the serialized input.

pub async fn content_get<T>(&self, input: &T) -> Result<Option<Vec<u8>>>

where T: Serialize + ?Sized,

Read the memo entry stored under Self::content_key of input.

pub async fn content_put<T>(&self, input: &T, value: &[u8]) -> Result<()>

where T: Serialize + ?Sized,

Store value under Self::content_key of input.

Trait Implementations

impl Clone for Memo

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Memo

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.