Skip to main content

RememberOptions

mubit_sdk

Struct RememberOptions 

Source 
pub struct RememberOptions {
Show 24 fields
    pub run_id: Option<String>,
    pub agent_id: Option<String>,
    pub item_id: Option<String>,
    pub content: String,
    pub content_type: String,
    pub metadata: Option<Value>,
    pub hints: Option<Value>,
    pub payload: Option<Value>,
    pub intent: Option<String>,
    pub lesson_type: Option<String>,
    pub lesson_scope: Option<String>,
    pub lesson_importance: Option<String>,
    pub lesson_conditions: Vec<String>,
    pub user_id: Option<String>,
    pub upsert_key: Option<String>,
    pub importance: Option<String>,
    pub source: Option<String>,
    pub lane: Option<String>,
    pub parallel: bool,
    pub idempotency_key: Option<String>,
    pub wait: bool,
    pub timeout_ms: Option<u64>,
    pub poll_interval_ms: u64,
    pub occurrence_time: Option<i64>,

}

Fields§

§run_id: Option<String>§agent_id: Option<String>§item_id: Option<String>§content: String§content_type: String§metadata: Option<Value>§hints: Option<Value>§payload: Option<Value>§intent: Option<String>§lesson_type: Option<String>§lesson_scope: Option<String>§lesson_importance: Option<String>§lesson_conditions: Vec<String>§user_id: Option<String>§upsert_key: Option<String>§importance: Option<String>§source: Option<String>§lane: Option<String>§parallel: bool§idempotency_key: Option<String>§wait: bool§timeout_ms: Option<u64>§poll_interval_ms: u64§occurrence_time: Option<i64>

When the event actually occurred (unix seconds). Distinct from ingestion time. Used for temporal queries about when events happened vs when the system learned about them.

Implementations§

Source§

impl RememberOptions

Source

pub fn new(content: impl Into<String>) -> Self

Examples found in repository?
examples/internal/lessons_lifecycle.rs (line 24)
12async fn main() -> Result<(), Box<dyn Error>> {
13    let name = "internal_lessons_lifecycle";
14    let started = Instant::now();
15    let client = create_client().await?;
16    let run_id = new_run_id("internal_lessons_lifecycle");
17    client.set_run_id(Some(run_id.clone()));
18    client.set_transport(TransportMode::Http);
19    let mut passed = true;
20    let mut detail = "validated raw lessons lifecycle".to_string();
21    let mut metrics = json!({});
22
23    let scenario = async {
24        let mut remember = RememberOptions::new("Always verify the stored deductible before approving reimbursement.");
25        remember.run_id = Some(run_id.clone());
26        remember.intent = Some("lesson".into());
27        remember.lesson_type = Some("success".into());
28        remember.lesson_scope = Some("session".into());
29        client.remember(remember).await?;
30
31        let mut lessons = serde_json::Value::Null;
32        for _ in 0..24 {
33            let current = client
34                .control
35                .lessons(json!({"run_id": run_id, "limit": 10}))
36                .await?;
37            let has_lesson = current
38                .get("lessons")
39                .and_then(|v| v.as_array())
40                .map(|items| !items.is_empty())
41                .unwrap_or(false);
42            lessons = current;
43            if has_lesson {
44                break;
45            }
46            sleep(Duration::from_millis(500)).await;
47        }
48        let lesson_id = lessons.get("lessons").and_then(|v| v.as_array()).and_then(|items| items.iter().find_map(|item| item.get("id").and_then(|v| v.as_str()))).ok_or_else(|| boxed_error(format!("expected lesson in lifecycle test: {lessons}")))?.to_string();
49        let deleted = client.control.delete_lesson(json!({"lesson_id": lesson_id})).await?;
50        let remaining = client.control.lessons(json!({"run_id": run_id, "limit": 10})).await?;
51        require(deleted.get("success").and_then(Value::as_bool).unwrap_or(true), format!("delete_lesson failed: {deleted}"))?;
52        require(!remaining.get("lessons").and_then(|v| v.as_array()).map(|items| items.iter().any(|item| item.get("id").and_then(|v| v.as_str()) == Some(lesson_id.as_str()))).unwrap_or(false), format!("lesson still present after delete: {remaining}"))?;
53        metrics = json!({"run_id": run_id, "lesson_id": lesson_id});
54        Ok::<(), Box<dyn Error>>(())
55    }.await;
56
57    if let Err(err) = scenario { passed = false; detail = err.to_string(); }
58    let cleanup_ok = cleanup_run(&client, &run_id).await;
59    if !cleanup_ok { passed = false; detail = format!("{detail} | cleanup failures"); }
60    print_summary(name, passed, &detail, &metrics, started.elapsed().as_secs_f64(), cleanup_ok);
61    if passed { Ok(()) } else { Err(boxed_error(detail)) }
62}
More examples
Hide additional examples
examples/helper_remember_recall.rs (lines 24-26)
11async fn main() -> Result<(), Box<dyn Error>> {
12    let name = "helper_remember_recall";
13    let started = Instant::now();
14    let client = create_client().await?;
15    let run_id = new_run_id("helper_remember_recall");
16    client.set_run_id(Some(run_id.clone()));
17    client.set_transport(TransportMode::Http);
18
19    let mut passed = true;
20    let mut detail = "validated helper remember -> recall flow".to_string();
21    let mut metrics = json!({});
22
23    let scenario = async {
24        let mut remember = RememberOptions::new(
25            "Before retrying cache rebuilds, verify the token signer has rotated cleanly.",
26        );
27        remember.run_id = Some(run_id.clone());
28        remember.agent_id = Some("helper-example".to_string());
29        remember.intent = Some("lesson".to_string());
30        remember.lesson_type = Some("success".to_string());
31        remember.lesson_scope = Some("session".to_string());
32        remember.metadata = Some(json!({ "source": "rust-helper-example" }));
33        remember.occurrence_time = Some(std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs() as i64 - 86400);
34
35        let remembered = client.remember(remember).await?;
36        require(
37            remembered
38                .get("done")
39                .and_then(|value| value.as_bool())
40                .unwrap_or(false),
41            format!("remember should wait for ingest completion: {remembered}"),
42        )?;
43
44        let mut recall = RecallOptions::new("What should I verify before retrying cache rebuilds?");
45        recall.run_id = Some(run_id.clone());
46        recall.entry_types = vec!["lesson".to_string(), "fact".to_string()];
47        let answer = client.recall(recall).await?;
48        let evidence = answer
49            .get("evidence")
50            .and_then(|value| value.as_array())
51            .ok_or_else(|| boxed_error(format!("evidence missing: {answer}")))?;
52        require(!evidence.is_empty(), format!("evidence missing: {answer}"))?;
53        require(
54            answer
55                .get("final_answer")
56                .and_then(|value| value.as_str())
57                .is_some(),
58            format!("final answer missing: {answer}"),
59        )?;
60
61        metrics = json!({
62            "run_id": run_id,
63            "evidence_count": evidence.len(),
64            "confidence": answer.get("confidence").cloned().unwrap_or(serde_json::Value::Null),
65        });
66
67        Ok::<(), Box<dyn Error>>(())
68    }
69    .await;
70
71    if let Err(err) = scenario {
72        passed = false;
73        detail = err.to_string();
74    }
75
76    let cleanup_ok = cleanup_run(&client, &run_id).await;
77    if !cleanup_ok {
78        passed = false;
79        detail = format!("{detail} | cleanup failures");
80    }
81
82    print_summary(
83        name,
84        passed,
85        &detail,
86        &metrics,
87        started.elapsed().as_secs_f64(),
88        cleanup_ok,
89    );
90
91    if passed {
92        Ok(())
93    } else {
94        Err(boxed_error(detail))
95    }
96}
examples/public/04_memory_health_and_diagnose.rs (lines 26-28)
13async fn main() -> Result<(), Box<dyn Error>> {
14    let name = "public_04_memory_health_and_diagnose";
15    let started = Instant::now();
16    let client = create_client().await?;
17    let run_id = new_run_id("public_04_memory_health_and_diagnose");
18    client.set_run_id(Some(run_id.clone()));
19    client.set_transport(TransportMode::Http);
20
21    let mut passed = true;
22    let mut detail = "validated helper context + diagnose + memory health flow".to_string();
23    let mut metrics = json!({});
24
25    let scenario = async {
26        let mut remember = RememberOptions::new(
27            "Deploys fail when the migration checksum is stale after a force-push.",
28        );
29        remember.run_id = Some(run_id.clone());
30        remember.agent_id = Some("observer".to_string());
31        remember.intent = Some("lesson".to_string());
32        remember.lesson_type = Some("failure".to_string());
33        remember.lesson_scope = Some("session".to_string());
34        remember.lesson_importance = Some("high".to_string());
35        remember.metadata = Some(json!({ "source": "rust-helper-example" }));
36        client.remember(remember).await?;
37
38        let mut context_opts = GetContextOptions::default();
39        context_opts.run_id = Some(run_id.clone());
40        context_opts.query = Some("Why did the deploy fail?".to_string());
41        context_opts.entry_types = vec!["lesson".to_string()];
42        context_opts.mode = Some("summary".to_string());
43        let context = client.get_context(context_opts).await?;
44
45        let mut diagnose = DiagnoseOptions::new("deploy failed because migration checksum is stale");
46        diagnose.run_id = Some(run_id.clone());
47        diagnose.error_type = Some("deploy".to_string());
48        diagnose.limit = 5;
49        let diagnosis = client.diagnose(diagnose).await?;
50
51        let mut health_opts = MemoryHealthOptions::default();
52        health_opts.run_id = Some(run_id.clone());
53        health_opts.limit = 100;
54        let health = client.memory_health(health_opts).await?;
55
56        let section_summaries = context
57            .get("section_summaries")
58            .and_then(|value| value.as_array())
59            .ok_or_else(|| boxed_error(format!("section summaries missing: {context}")))?;
60        require(
61            diagnosis
62                .get("total_failure_lessons")
63                .and_then(|value| value.as_u64())
64                .unwrap_or(0)
65                >= 1,
66            format!("diagnose should surface a failure lesson: {diagnosis}"),
67        )?;
68        require(
69            health.get("entry_counts").and_then(|value| value.as_object()).is_some(),
70            format!("memory health missing entry counts: {health}"),
71        )?;
72
73        metrics = json!({
74            "run_id": run_id,
75            "section_count": section_summaries.len(),
76            "total_failure_lessons": diagnosis.get("total_failure_lessons").cloned().unwrap_or(serde_json::Value::Null),
77            "entry_count_keys": health.get("entry_counts").and_then(|value| value.as_object()).map(|map| map.len()).unwrap_or(0),
78        });
79
80        Ok::<(), Box<dyn Error>>(())
81    }
82    .await;
83
84    if let Err(err) = scenario {
85        passed = false;
86        detail = err.to_string();
87    }
88
89    let cleanup_ok = cleanup_run(&client, &run_id).await;
90    if !cleanup_ok {
91        passed = false;
92        detail = format!("{detail} | cleanup failures");
93    }
94
95    print_summary(
96        name,
97        passed,
98        &detail,
99        &metrics,
100        started.elapsed().as_secs_f64(),
101        cleanup_ok,
102    );
103
104    if passed {
105        Ok(())
106    } else {
107        Err(boxed_error(detail))
108    }
109}
examples/helper_context_diagnose_memory_health.rs (lines 26-28)
13async fn main() -> Result<(), Box<dyn Error>> {
14    let name = "helper_context_diagnose_memory_health";
15    let started = Instant::now();
16    let client = create_client().await?;
17    let run_id = new_run_id("helper_context_diagnose_memory_health");
18    client.set_run_id(Some(run_id.clone()));
19    client.set_transport(TransportMode::Http);
20
21    let mut passed = true;
22    let mut detail = "validated helper context + diagnose + memory health flow".to_string();
23    let mut metrics = json!({});
24
25    let scenario = async {
26        let mut remember = RememberOptions::new(
27            "Deploys fail when the migration checksum is stale after a force-push.",
28        );
29        remember.run_id = Some(run_id.clone());
30        remember.agent_id = Some("observer".to_string());
31        remember.intent = Some("lesson".to_string());
32        remember.lesson_type = Some("failure".to_string());
33        remember.lesson_scope = Some("session".to_string());
34        remember.lesson_importance = Some("high".to_string());
35        remember.metadata = Some(json!({ "source": "rust-helper-example" }));
36        client.remember(remember).await?;
37
38        let mut context_opts = GetContextOptions::default();
39        context_opts.run_id = Some(run_id.clone());
40        context_opts.query = Some("Why did the deploy fail?".to_string());
41        context_opts.entry_types = vec!["lesson".to_string()];
42        context_opts.mode = Some("summary".to_string());
43        let context = client.get_context(context_opts).await?;
44
45        let mut diagnose = DiagnoseOptions::new("deploy failed because migration checksum is stale");
46        diagnose.run_id = Some(run_id.clone());
47        diagnose.error_type = Some("deploy".to_string());
48        diagnose.limit = 5;
49        let diagnosis = client.diagnose(diagnose).await?;
50
51        let mut health_opts = MemoryHealthOptions::default();
52        health_opts.run_id = Some(run_id.clone());
53        health_opts.limit = 100;
54        let health = client.memory_health(health_opts).await?;
55
56        let section_summaries = context
57            .get("section_summaries")
58            .and_then(|value| value.as_array())
59            .ok_or_else(|| boxed_error(format!("section summaries missing: {context}")))?;
60        require(
61            diagnosis
62                .get("total_failure_lessons")
63                .and_then(|value| value.as_u64())
64                .unwrap_or(0)
65                >= 1,
66            format!("diagnose should surface a failure lesson: {diagnosis}"),
67        )?;
68        require(
69            health.get("entry_counts").and_then(|value| value.as_object()).is_some(),
70            format!("memory health missing entry counts: {health}"),
71        )?;
72
73        metrics = json!({
74            "run_id": run_id,
75            "section_count": section_summaries.len(),
76            "total_failure_lessons": diagnosis.get("total_failure_lessons").cloned().unwrap_or(serde_json::Value::Null),
77            "entry_count_keys": health.get("entry_counts").and_then(|value| value.as_object()).map(|map| map.len()).unwrap_or(0),
78        });
79
80        Ok::<(), Box<dyn Error>>(())
81    }
82    .await;
83
84    if let Err(err) = scenario {
85        passed = false;
86        detail = err.to_string();
87    }
88
89    let cleanup_ok = cleanup_run(&client, &run_id).await;
90    if !cleanup_ok {
91        passed = false;
92        detail = format!("{detail} | cleanup failures");
93    }
94
95    print_summary(
96        name,
97        passed,
98        &detail,
99        &metrics,
100        started.elapsed().as_secs_f64(),
101        cleanup_ok,
102    );
103
104    if passed {
105        Ok(())
106    } else {
107        Err(boxed_error(detail))
108    }
109}
examples/public/01_remember_recall.rs (lines 25-27)
11async fn main() -> Result<(), Box<dyn Error>> {
12    let name = "public_01_remember_recall";
13    let started = Instant::now();
14    let client = create_client().await?;
15    let run_id = new_run_id("public_01_remember_recall");
16    client.set_run_id(Some(run_id.clone()));
17    client.set_transport(TransportMode::Http);
18
19    let mut passed = true;
20    let mut detail = "validated helper remember -> recall flow with upsert_key idempotency".to_string();
21    let mut metrics = json!({});
22
23    let scenario = async {
24        let upsert_key = format!("remember-recall-{run_id}");
25        let mut remember = RememberOptions::new(
26            "Before retrying cache rebuilds, verify the token signer has rotated cleanly.",
27        );
28        remember.run_id = Some(run_id.clone());
29        remember.agent_id = Some("helper-example".to_string());
30        remember.intent = Some("lesson".to_string());
31        remember.lesson_type = Some("success".to_string());
32        remember.lesson_scope = Some("session".to_string());
33        remember.upsert_key = Some(upsert_key.clone());
34        remember.metadata = Some(json!({ "source": "rust-helper-example" }));
35
36        let remembered = client.remember(remember).await?;
37        require(
38            remembered
39                .get("done")
40                .and_then(|value| value.as_bool())
41                .unwrap_or(false),
42            format!("remember should wait for ingest completion: {remembered}"),
43        )?;
44
45        let mut updated = RememberOptions::new(
46            "Before retrying cache rebuilds, verify the signer rotation completed and invalidate stale cache tokens.",
47        );
48        updated.run_id = Some(run_id.clone());
49        updated.agent_id = Some("helper-example".to_string());
50        updated.intent = Some("lesson".to_string());
51        updated.lesson_type = Some("success".to_string());
52        updated.lesson_scope = Some("session".to_string());
53        updated.upsert_key = Some(upsert_key.clone());
54        updated.metadata = Some(json!({ "source": "rust-helper-example", "revision": 2 }));
55
56        let updated_response = client.remember(updated).await?;
57        require(
58            updated_response
59                .get("done")
60                .and_then(|value| value.as_bool())
61                .unwrap_or(false),
62            format!("upsert remember should wait for ingest completion: {updated_response}"),
63        )?;
64
65        let mut recall = RecallOptions::new("What should I verify before retrying cache rebuilds?");
66        recall.run_id = Some(run_id.clone());
67        recall.entry_types = vec!["lesson".to_string(), "fact".to_string()];
68        let answer = client.recall(recall).await?;
69        let evidence = answer
70            .get("evidence")
71            .and_then(|value| value.as_array())
72            .ok_or_else(|| boxed_error(format!("evidence missing: {answer}")))?;
73        require(!evidence.is_empty(), format!("evidence missing: {answer}"))?;
74        let rendered = evidence
75            .iter()
76            .filter_map(|item| item.get("content").and_then(|value| value.as_str()))
77            .collect::<Vec<_>>()
78            .join(" ");
79        require(
80            rendered.contains("invalidate stale cache tokens"),
81            format!("upserted lesson should be recalled: {answer}"),
82        )?;
83        require(
84            answer
85                .get("final_answer")
86                .and_then(|value| value.as_str())
87                .is_some(),
88            format!("final answer missing: {answer}"),
89        )?;
90
91        metrics = json!({
92            "run_id": run_id,
93            "evidence_count": evidence.len(),
94            "confidence": answer.get("confidence").cloned().unwrap_or(serde_json::Value::Null),
95            "upsert_key": upsert_key,
96        });
97
98        Ok::<(), Box<dyn Error>>(())
99    }
100    .await;
101
102    if let Err(err) = scenario {
103        passed = false;
104        detail = err.to_string();
105    }
106
107    let cleanup_ok = cleanup_run(&client, &run_id).await;
108    if !cleanup_ok {
109        passed = false;
110        detail = format!("{detail} | cleanup failures");
111    }
112
113    print_summary(
114        name,
115        passed,
116        &detail,
117        &metrics,
118        started.elapsed().as_secs_f64(),
119        cleanup_ok,
120    );
121
122    if passed {
123        Ok(())
124    } else {
125        Err(boxed_error(detail))
126    }
127}
examples/helper_mas_learning_loop.rs (lines 35-37)
14async fn main() -> Result<(), Box<dyn Error>> {
15    let name = "helper_mas_learning_loop";
16    let started = Instant::now();
17    let client = create_client().await?;
18    let run_id = new_run_id("helper_mas_learning_loop");
19    client.set_run_id(Some(run_id.clone()));
20    client.set_transport(TransportMode::Http);
21
22    let mut passed = true;
23    let mut detail = "validated helper MAS checkpoint/outcome/strategies flow".to_string();
24    let mut metrics = json!({});
25
26    let scenario = async {
27        let mut register = RegisterAgentOptions::new("planner");
28        register.run_id = Some(run_id.clone());
29        register.role = "planner".to_string();
30        register.read_scopes = vec!["rule".to_string(), "lesson".to_string(), "fact".to_string()];
31        register.write_scopes = vec!["lesson".to_string(), "trace".to_string()];
32        register.shared_memory_lanes = vec!["knowledge".to_string(), "history".to_string()];
33        client.register_agent(register).await?;
34
35        let mut remember = RememberOptions::new(
36            "If a retry succeeds after token signer rotation, record it as a reusable recovery pattern.",
37        );
38        remember.run_id = Some(run_id.clone());
39        remember.agent_id = Some("planner".to_string());
40        remember.intent = Some("lesson".to_string());
41        remember.lesson_type = Some("success".to_string());
42        remember.lesson_scope = Some("session".to_string());
43        remember.lesson_importance = Some("high".to_string());
44        client.remember(remember).await?;
45
46        let mut checkpoint = CheckpointOptions::new(
47            "Planner isolated the recovery path to token signer rotation.",
48        );
49        checkpoint.run_id = Some(run_id.clone());
50        checkpoint.label = Some("pre-compaction-1".to_string());
51        checkpoint.metadata = Some(json!({ "stage": "analysis" }));
52        checkpoint.agent_id = Some("planner".to_string());
53        let checkpoint_response = client.checkpoint(checkpoint).await?;
54
55        let mut list_agents = ListAgentsOptions::default();
56        list_agents.run_id = Some(run_id.clone());
57        let agents = client.list_agents(list_agents).await?;
58
59        let lessons = client.control.lessons(json!({ "run_id": run_id, "limit": 10 })).await?;
60        let lesson_id = lessons
61            .get("lessons")
62            .and_then(|value| value.as_array())
63            .and_then(|items| items.first())
64            .and_then(|item| item.get("id"))
65            .and_then(|value| value.as_str())
66            .ok_or_else(|| boxed_error(format!("expected at least one lesson to record outcome against: {lessons}")))?
67            .to_string();
68
69        let mut outcome = RecordOutcomeOptions::new(lesson_id, "success");
70        outcome.run_id = Some(run_id.clone());
71        outcome.signal = 0.75;
72        outcome.rationale = "Recovery succeeded after following the stored lesson.".to_string();
73        outcome.agent_id = Some("planner".to_string());
74        let outcome_response = client.record_outcome(outcome).await?;
75
76        let mut strategies = SurfaceStrategiesOptions::default();
77        strategies.run_id = Some(run_id.clone());
78        strategies.lesson_types = vec!["success".to_string(), "failure".to_string()];
79        strategies.max_strategies = 5;
80        let strategy_response = client.surface_strategies(strategies).await?;
81
82        require(
83            checkpoint_response
84                .get("success")
85                .and_then(|value| value.as_bool())
86                .unwrap_or(false),
87            format!("checkpoint failed: {checkpoint_response}"),
88        )?;
89        let agent_count = agents
90            .get("agents")
91            .and_then(|value| value.as_array())
92            .map(|items| items.len())
93            .unwrap_or(0);
94        require(agent_count == 1, format!("agent registration missing: {agents}"))?;
95        require(
96            outcome_response
97                .get("success")
98                .and_then(|value| value.as_bool())
99                .unwrap_or(false),
100            format!("record_outcome failed: {outcome_response}"),
101        )?;
102        let strategy_count = strategy_response
103            .get("strategies")
104            .and_then(|value| value.as_array())
105            .map(|items| items.len())
106            .unwrap_or(0);
107
108        metrics = json!({
109            "run_id": run_id,
110            "checkpoint_id": checkpoint_response.get("checkpoint_id").cloned().unwrap_or(serde_json::Value::Null),
111            "agent_count": agent_count,
112            "strategy_count": strategy_count,
113        });
114
115        Ok::<(), Box<dyn Error>>(())
116    }
117    .await;
118
119    if let Err(err) = scenario {
120        passed = false;
121        detail = err.to_string();
122    }
123
124    let cleanup_ok = cleanup_run(&client, &run_id).await;
125    if !cleanup_ok {
126        passed = false;
127        detail = format!("{detail} | cleanup failures");
128    }
129
130    print_summary(
131        name,
132        passed,
133        &detail,
134        &metrics,
135        started.elapsed().as_secs_f64(),
136        cleanup_ok,
137    );
138
139    if passed {
140        Ok(())
141    } else {
142        Err(boxed_error(detail))
143    }
144}
Additional examples can be found in:

Trait Implementations§

Source§

impl Clone for RememberOptions

Source§

fn clone(&self) -> RememberOptions

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for RememberOptions

Source§

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> FromRef<T> for T
where T: Clone,

Source§

fn from_ref(input: &T) -> T

Converts to this type from a reference to the input type.
Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoRequest<T> for T

Source§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
Source§

impl<T> PolicyExt for T
where T: ?Sized,

Source§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow only if self and other return Action::Follow. Read more
Source§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow if either self or other returns Action::Follow. Read more
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more