sim-nest 0.1.5

The SIM constellation umbrella facade: one crate that re-exports the runtime kernel, codecs, number domains, and libraries behind features.
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use std::sync::Arc;

use sim_kernel::{Args, DefaultFactory, EagerPolicy, Expr, Symbol, Value};

use crate::runtime::install_core_runtime;

fn cx() -> sim_kernel::Cx {
    let mut cx = sim_kernel::Cx::new(Arc::new(EagerPolicy), Arc::new(DefaultFactory));
    install_core_runtime(&mut cx);
    cx
}

fn number_value(cx: &mut sim_kernel::Cx, text: &str) -> Value {
    cx.factory()
        .number_literal(Symbol::qualified("numbers", "f64"), text.to_owned())
        .unwrap()
}

#[test]
fn runtime_shape_hook_wraps_shape_and_runs_trace_hook() {
    let mut cx = cx();
    let any = cx.resolve_shape(&Symbol::qualified("core", "Any")).unwrap();
    let trace = cx
        .call_function(&Symbol::qualified("shape", "hook-trace"), Args::new(vec![]))
        .unwrap();
    let hooks = cx.factory().list(vec![trace]).unwrap();
    let hooked = cx
        .call_function(
            &Symbol::qualified("shape", "hook"),
            Args::new(vec![any, hooks]),
        )
        .unwrap();

    let matched = hooked
        .object()
        .as_shape()
        .unwrap()
        .check_expr(&mut cx, &Expr::Bool(true))
        .unwrap();

    assert!(matched.accepted);
    assert_eq!(
        matched
            .diagnostics
            .iter()
            .filter(|diagnostic| diagnostic.message.starts_with("shape-hook:mark"))
            .count(),
        2
    );
}

#[test]
fn runtime_score_floor_hook_adjusts_hooked_shape_score() {
    let mut cx = cx();
    let any = cx.resolve_shape(&Symbol::qualified("core", "Any")).unwrap();
    let floor = number_value(&mut cx, "40");
    let hook = cx
        .call_function(
            &Symbol::qualified("shape", "hook-score-floor"),
            Args::new(vec![floor]),
        )
        .unwrap();
    let hooks = cx.factory().list(vec![hook]).unwrap();
    let hooked = cx
        .call_function(
            &Symbol::qualified("shape", "hook"),
            Args::new(vec![any, hooks]),
        )
        .unwrap();

    let matched = hooked
        .object()
        .as_shape()
        .unwrap()
        .check_expr(&mut cx, &Expr::Bool(true))
        .unwrap();

    assert!(matched.accepted);
    assert_eq!(matched.score.value(), 40);
}

#[test]
fn runtime_builtin_hook_values_have_stable_display() {
    let mut cx = cx();
    let floor = number_value(&mut cx, "7");
    let prefix = cx.factory().string("shape-hook:accept".to_owned()).unwrap();
    let hooks = vec![
        (
            Symbol::qualified("shape", "hook-trace"),
            Vec::new(),
            "#<shape-hook shape/trace-mark mark>",
        ),
        (
            Symbol::qualified("shape", "hook-score-floor"),
            vec![floor],
            "#<shape-hook shape/score-floor annotate>",
        ),
        (
            Symbol::qualified("shape", "hook-accept-on-no-diagnostics"),
            Vec::new(),
            "#<shape-hook shape/accept-on-no-diagnostics accept>",
        ),
        (
            Symbol::qualified("shape", "hook-discard-on-diagnostic-prefix"),
            vec![prefix],
            "#<shape-hook shape/discard-on-diagnostic-prefix discard>",
        ),
    ];

    for (symbol, args, expected) in hooks {
        let value = cx.call_function(&symbol, Args::new(args)).unwrap();
        assert_eq!(value.object().display(&mut cx).unwrap(), expected);
    }
}