hugr_core/extension/prelude/
unwrap_builder.rs

1use std::iter;
2
3use crate::{
4    builder::{BuildError, BuildHandle, Dataflow, DataflowSubContainer, SubContainer},
5    extension::prelude::{ConstError, PANIC_OP_ID},
6    ops::handle::DataflowOpID,
7    types::{SumType, Type, TypeArg, TypeRow},
8    Wire,
9};
10use itertools::{zip_eq, Itertools as _};
11
12use super::PRELUDE;
13
14/// Extend dataflow builders with methods for building unwrap operations.
15pub trait UnwrapBuilder: Dataflow {
16    /// Add a panic operation to the dataflow with the given error.
17    fn add_panic(
18        &mut self,
19        err: ConstError,
20        output_row: impl IntoIterator<Item = Type>,
21        inputs: impl IntoIterator<Item = (Wire, Type)>,
22    ) -> Result<BuildHandle<DataflowOpID>, BuildError> {
23        let (input_wires, input_types): (Vec<_>, Vec<_>) = inputs.into_iter().unzip();
24        let input_arg: TypeArg = input_types
25            .into_iter()
26            .map(<TypeArg as From<_>>::from)
27            .collect_vec()
28            .into();
29        let output_arg: TypeArg = output_row
30            .into_iter()
31            .map(<TypeArg as From<_>>::from)
32            .collect_vec()
33            .into();
34        let op = PRELUDE.instantiate_extension_op(&PANIC_OP_ID, [input_arg, output_arg])?;
35        let err = self.add_load_value(err);
36        self.add_dataflow_op(op, iter::once(err).chain(input_wires))
37    }
38
39    /// Build an unwrap operation for a sum type to extract the variant at the given tag
40    /// or panic if the tag is not the expected value.
41    fn build_unwrap_sum<const N: usize>(
42        &mut self,
43        tag: usize,
44        sum_type: SumType,
45        input: Wire,
46    ) -> Result<[Wire; N], BuildError> {
47        let variants: Vec<TypeRow> = (0..sum_type.num_variants())
48            .map(|i| {
49                let tr_rv = sum_type.get_variant(i).unwrap().to_owned();
50                TypeRow::try_from(tr_rv)
51            })
52            .collect::<Result<_, _>>()?;
53
54        // TODO don't panic if tag >= num_variants
55        let output_row = variants.get(tag).unwrap();
56
57        let mut conditional =
58            self.conditional_builder((variants.clone(), input), [], output_row.clone())?;
59        for (i, variant) in variants.iter().enumerate() {
60            let mut case = conditional.case_builder(i)?;
61            if i == tag {
62                let outputs = case.input_wires();
63                case.finish_with_outputs(outputs)?;
64            } else {
65                let output_row = output_row.iter().cloned();
66                let inputs = zip_eq(case.input_wires(), variant.iter().cloned());
67                let err =
68                    ConstError::new(1, format!("Expected variant {} but got variant {}", tag, i));
69                let outputs = case.add_panic(err, output_row, inputs)?.outputs();
70                case.finish_with_outputs(outputs)?;
71            }
72        }
73        Ok(conditional.finish_sub_container()?.outputs_arr())
74    }
75}
76
77impl<D: Dataflow> UnwrapBuilder for D {}
78
79#[cfg(test)]
80mod tests {
81    use super::*;
82    use crate::{
83        builder::{DFGBuilder, DataflowHugr},
84        extension::prelude::{bool_t, option_type},
85        types::Signature,
86    };
87
88    #[test]
89    fn test_build_unwrap() {
90        let mut builder = DFGBuilder::new(
91            Signature::new(Type::from(option_type(bool_t())), bool_t()).with_prelude(),
92        )
93        .unwrap();
94
95        let [opt] = builder.input_wires_arr();
96
97        let [res] = builder
98            .build_unwrap_sum(1, option_type(bool_t()), opt)
99            .unwrap();
100        builder.finish_hugr_with_outputs([res]).unwrap();
101    }
102}
hugr_core/extension/prelude/unwrap_builder.rs

hugr_core/extension/prelude/
unwrap_builder.rs
