polydat 0.3.2

Polydat — a variates construction engine
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

// Copyright 2024-2026 Jonathan Shook
// SPDX-License-Identifier: Apache-2.0

//! Illustration: `name := for ...` binds a comprehension as a value. The
//! wire carries a Streamer; derivations filter and order it; streams
//! from one wire advance independently.

use polydat::iteration::comprehension::strategies::TupleValue;

fn show(label: &str, s: &polydat::iteration::comprehension::StreamerValue) {
    let tuples: Vec<String> = s
        .coordinate_stream()
        .map(|t| {
            let cells: Vec<String> = t
                .bindings
                .iter()
                .map(|(_, v)| match v {
                    TupleValue::I64(n) => n.to_string(),
                    TupleValue::U64(n) => n.to_string(),
                    other => format!("{other:?}"),
                })
                .collect();
            format!("({})", cells.join(","))
        })
        .collect();
    println!(
        "{label:<8} {:?}  {:>2} tuples  {}",
        s.cardinality(),
        tuples.len(),
        tuples.join(" ")
    );
}

fn main() {
    let mut kernel = polydat::dsl::compile_polydat_kernel(
        r#"
        input cycle: u64

        base    := for k in 1..4, limit in 10,20,30
        corners := for base where {k} == 1 || {k} == 3
        sampled := for base order halton/4
        label   := "plan: {base}"
    "#,
    )
    .expect("compile failed");

    kernel.set_inputs(&[0]);
    println!("{}", kernel.pull("label").as_str());
    for name in ["base", "corners", "sampled"] {
        let value = kernel.pull(name);
        show(name, value.as_streamer().expect("streamer"));
    }

    // Two streams from one wire never share a cursor.
    let value = kernel.pull("base");
    let base = value.as_streamer().unwrap();
    let mut a = base.coordinate_stream();
    let b = base.coordinate_stream();
    a.next();
    a.next();
    println!(
        "after two pulls on a: a has {} left, b has {}",
        a.count(),
        b.count()
    );
}