strykelang 0.8.5

A highly parallel Perl 5 interpreter written in Rust
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

//! Extra tests for async/await and thread pools.

use crate::run;

#[test]
fn test_async_await_basic() {
    let code = r#"
        my $t = async { 10 + 32 };
        await($t);
    "#;
    assert_eq!(run(code).expect("run").to_int(), 42);
}

#[test]
fn test_async_parallel_execution() {
    // Two tasks running in parallel
    let code = r#"
        my $t1 = async { sleep(0.1); 1 };
        my $t2 = async { sleep(0.1); 2 };
        await($t1) + await($t2);
    "#;
    assert_eq!(run(code).expect("run").to_int(), 3);
}

#[test]
fn test_async_error_propagation() {
    let code = r#"
        my $t = async { die "async_fail" };
        eval { await($t) };
        $@ =~ /async_fail/ ? "ok" : "fail";
    "#;
    assert_eq!(run(code).expect("run").to_string(), "ok");
}

#[test]
fn test_async_closure_capture() {
    let code = r#"
        my $x = 100;
        my $t = async { $x + 1 };
        await($t);
    "#;
    assert_eq!(run(code).expect("run").to_int(), 101);
}

#[test]
fn test_mysync_variable_sharing() {
    let code = r#"
        mysync $counter = 0;
        my @t;
        for (1..10) {
            push @t, async { $counter++ };
        }
        for (@t) { await($_) }
        $counter;
    "#;
    assert_eq!(run(code).expect("run").to_int(), 10);
}

#[test]
fn test_async_stress() {
    // Spawn 100 async tasks
    let code = r#"
        my @tasks = map { async { $_ } } (1..100);
        my $sum = 0;
        for (@tasks) { $sum += await($_); }
        $sum;
    "#;
    assert_eq!(run(code).expect("run").to_int(), 5050);
}