lex-runtime 0.9.4

Effect handler runtime + capability policy for Lex.
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

//! std.flow extensions: `parallel_list` (variadic counterpart to
//! `parallel`). Spec §11.2 — sequential under the hood; threading is
//! reserved for a future scheduler.

use lex_ast::canonicalize_program;
use lex_bytecode::{compile_program, vm::Vm, Value};
use lex_runtime::{DefaultHandler, Policy};
use lex_syntax::parse_source;

fn run(src: &str, func: &str, args: Vec<Value>) -> Value {
    let prog = parse_source(src).expect("parse");
    let stages = canonicalize_program(&prog);
    if let Err(errs) = lex_types::check_program(&stages) {
        panic!("type errors: {errs:#?}");
    }
    let bc = compile_program(&stages);
    let handler = DefaultHandler::new(Policy::permissive());
    let mut vm = Vm::with_handler(&bc, Box::new(handler));
    vm.call(func, args).expect("vm")
}

#[test]
fn parallel_list_runs_three_actions_in_input_order() {
    let src = r#"
import "std.flow" as flow
fn run3() -> List[Int] {
  flow.parallel_list([
    fn () -> Int { 7 },
    fn () -> Int { 11 },
    fn () -> Int { 13 }
  ])
}
"#;
    let r = run(src, "run3", vec![]);
    assert_eq!(
        r,
        Value::List(vec![Value::Int(7), Value::Int(11), Value::Int(13)].into())
    );
}

#[test]
fn parallel_list_empty_returns_empty_list() {
    let src = r#"
import "std.flow" as flow
fn run0() -> List[Int] {
  flow.parallel_list([])
}
"#;
    let r = run(src, "run0", vec![]);
    assert_eq!(r, Value::List(vec![].into()));
}

#[test]
fn parallel_list_single_action_returns_singleton() {
    let src = r#"
import "std.flow" as flow
fn run1() -> List[Int] {
  flow.parallel_list([fn () -> Int { 42 }])
}
"#;
    let r = run(src, "run1", vec![]);
    assert_eq!(r, Value::List(vec![Value::Int(42)].into()));
}

#[test]
fn parallel_list_preserves_captured_locals() {
    // Each closure captures a distinct local from the enclosing scope.
    // Verifies captures are read at call time without aliasing.
    let src = r#"
import "std.flow" as flow
fn run_caps() -> List[Int] {
  let a := 1
  let b := 2
  let c := 3
  flow.parallel_list([
    fn () -> Int { a + 10 },
    fn () -> Int { b + 20 },
    fn () -> Int { c + 30 }
  ])
}
"#;
    let r = run(src, "run_caps", vec![]);
    assert_eq!(
        r,
        Value::List(vec![Value::Int(11), Value::Int(22), Value::Int(33)].into())
    );
}

#[test]
fn parallel_list_works_with_string_return_type() {
    let src = r#"
import "std.flow" as flow
fn run_strs() -> List[Str] {
  flow.parallel_list([
    fn () -> Str { "alpha" },
    fn () -> Str { "beta" },
    fn () -> Str { "gamma" }
  ])
}
"#;
    let r = run(src, "run_strs", vec![]);
    assert_eq!(
        r,
        Value::List(vec![
            Value::Str("alpha".into()),
            Value::Str("beta".into()),
            Value::Str("gamma".into()),
        ].into())
    );
}