sim-lib-agent 0.1.1

Agent runtime surfaces for SIM.
Documentation 
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

use super::super::store::snapshot_entries;
use super::types::MemoryBackend;
use sim_kernel::{Cx, Error, Expr, Result, Value};

pub(super) fn answer_memory_request(
    memory: &dyn MemoryBackend,
    cx: &mut Cx,
    expr: Expr,
) -> Result<Value> {
    let (op, args) = memory_request_parts(expr)?;
    match op.as_str() {
        "append" | "memory/append" => {
            let [msg] = args.as_slice() else {
                return Err(Error::Eval(
                    "memory append frame expects one message".to_owned(),
                ));
            };
            let msg = crate::expr_to_value(cx, msg)?;
            memory.append(cx, msg)?;
            cx.factory().nil()
        }
        "recent" | "memory/recent" => {
            let [count] = args.as_slice() else {
                return Err(Error::Eval(
                    "memory recent frame expects one count".to_owned(),
                ));
            };
            let count =
                crate::u32_from_expr(count, "memory recent frame expects an integer count")?;
            let recent = memory.recent(cx, count)?;
            cx.factory().list(recent)
        }
        "scan" | "memory/scan" => {
            let entries = match args.as_slice() {
                [] => snapshot_entries(memory.snapshot(cx)?)?
                    .into_iter()
                    .map(|entry| crate::expr_to_value(cx, &entry))
                    .collect::<Result<Vec<_>>>()?,
                [count] => {
                    let count =
                        crate::u32_from_expr(count, "memory scan frame expects an integer count")?;
                    memory.recent(cx, count)?
                }
                _ => {
                    return Err(Error::Eval(
                        "memory scan frame expects zero or one count".to_owned(),
                    ));
                }
            };
            cx.factory().list(entries)
        }
        "search" | "memory/search" => {
            let [query, k] = args.as_slice() else {
                return Err(Error::Eval(
                    "memory search frame expects a query and count".to_owned(),
                ));
            };
            let k = crate::u32_from_expr(k, "memory search frame expects an integer count")?;
            let results = memory.search(cx, query.clone(), k)?;
            cx.factory().list(results)
        }
        "snapshot" | "memory/snapshot" => {
            let snapshot = memory.snapshot(cx)?;
            cx.factory().expr(snapshot)
        }
        "restore" | "memory/restore" => {
            let [snapshot] = args.as_slice() else {
                return Err(Error::Eval(
                    "memory restore frame expects one snapshot".to_owned(),
                ));
            };
            memory.restore(cx, snapshot.clone())?;
            cx.factory().nil()
        }
        _ => Err(Error::Eval(format!("unknown memory frame operation {op}"))),
    }
}

fn memory_request_parts(expr: Expr) -> Result<(String, Vec<Expr>)> {
    let (Expr::List(items) | Expr::Vector(items)) = expr else {
        return Err(Error::Eval(
            "memory request frames expect a list or vector payload".to_owned(),
        ));
    };
    let Some((head, rest)) = items.split_first() else {
        return Err(Error::Eval(
            "memory request frames cannot be empty".to_owned(),
        ));
    };
    let Expr::Symbol(symbol) = head else {
        return Err(Error::Eval(
            "memory request frames expect a symbol operation".to_owned(),
        ));
    };
    Ok((symbol.to_string(), rest.to_vec()))
}