wdl-engine 0.13.2

Execution engine for Workflow Description Language (WDL) documents.
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

//! Implements the `unzip` function from the WDL standard library.

use wdl_ast::Diagnostic;

use super::CallContext;
use super::Callback;
use super::Function;
use super::Signature;
use crate::Array;
use crate::Pair;
use crate::Value;

/// Creates a Pair of Arrays, the first containing the elements from the left
/// members of an Array of Pairs, and the second containing the right members.
///
/// If the array is empty, a pair of empty arrays is returned.
///
/// This is the inverse of the zip function.
///
/// https://github.com/openwdl/wdl/blob/wdl-1.2/SPEC.md#unzip
fn unzip(context: CallContext<'_>) -> Result<Value, Diagnostic> {
    debug_assert_eq!(context.arguments.len(), 1);

    let array = context.arguments[0]
        .value
        .as_array()
        .expect("argument should be an array");

    let pair_ty = context
        .return_type
        .as_pair()
        .expect("type should be a pair");

    let left_ty = pair_ty.left_type();
    debug_assert!(left_ty.as_array().is_some(), "left type should be an array");

    let right_ty = pair_ty.right_type();
    debug_assert!(
        right_ty.as_array().is_some(),
        "right type should be an array"
    );

    let mut left = Vec::with_capacity(array.len());
    let mut right = Vec::with_capacity(array.len());
    for v in array.as_slice() {
        let p = v.as_pair().expect("element should be a pair");
        left.push(p.left().clone());
        right.push(p.right().clone());
    }

    Ok(Pair::new_unchecked(
        context.return_type.clone(),
        Array::new_unchecked(left_ty.clone(), left).into(),
        Array::new_unchecked(right_ty.clone(), right).into(),
    )
    .into())
}

/// Gets the function describing `unzip`.
pub const fn descriptor() -> Function {
    Function::new(
        const {
            &[Signature::new(
                "(array: Array[Pair[X, Y]]) -> Pair[Array[X], Array[Y]]",
                Callback::Sync(unzip),
            )]
        },
    )
}

#[cfg(test)]
mod test {
    use pretty_assertions::assert_eq;
    use wdl_ast::version::V1;

    use crate::v1::test::TestEnv;
    use crate::v1::test::eval_v1_expr;

    #[tokio::test]
    async fn unzip() {
        let env = TestEnv::default();

        let value = eval_v1_expr(&env, V1::One, "unzip([])")
            .await
            .unwrap()
            .unwrap_pair();
        assert_eq!(value.left().as_array().unwrap().len(), 0);
        assert_eq!(value.right().as_array().unwrap().len(), 0);

        let value = eval_v1_expr(&env, V1::One, "unzip([(1, 'a'), (2, 'b'), (3, 'c')])")
            .await
            .unwrap()
            .unwrap_pair();
        let left: Vec<_> = value
            .left()
            .as_array()
            .unwrap()
            .as_slice()
            .iter()
            .map(|v| v.as_integer().unwrap())
            .collect();
        assert_eq!(left, [1, 2, 3]);
        let right: Vec<_> = value
            .right()
            .as_array()
            .unwrap()
            .as_slice()
            .iter()
            .map(|v| v.as_string().unwrap().as_str())
            .collect();
        assert_eq!(right, ["a", "b", "c"]);
    }
}