telltale-runtime 17.0.0

Choreographic programming for Telltale - effect-based distributed protocols
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

#![allow(clippy::unwrap_used)]
#![allow(clippy::expect_used)]

//! Direct test of parameterized roles parsing without using the proc macro

use telltale_runtime::compiler::{parse_dsl, project};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let dsl = r"
    protocol TestParamRoles =
      roles Coordinator, Worker[3]

      Coordinator { shard : 0 }
        -> Worker[0] : Task of jobs.Task
      Worker[0]
        -> Coordinator : Result of jobs.Result
    ";

    println!("Parsing choreography with parameterized roles...\n");

    // Parse the choreography
    let choreography = parse_dsl(dsl)?;

    println!("Successfully parsed choreography: {}", choreography.name);
    println!("  Roles:");
    for role in &choreography.roles {
        if let Some(size) = role.array_size() {
            println!(
                "    - {} (array size: {})",
                role.name(),
                quote::quote!(#size)
            );
        } else if role.index().is_some() {
            println!("    - {}[{}]", role.name(), role.index().unwrap());
        } else {
            println!("    - {}", role.name());
        }
    }

    // Validate
    choreography.validate()?;
    println!("\nChoreography validated successfully");

    // Project to local types
    println!("\nProjecting to local types:");
    for role in &choreography.roles {
        match project(&choreography, role) {
            Ok(local_type) => {
                println!("    - {}: {:?}", role.name(), local_type);
            }
            Err(e) => {
                println!("    - {}: Error - {}", role.name(), e);
            }
        }
    }

    println!("\nParameterized roles support is working!");

    Ok(())
}