ankha 0.2.3

Ankha scripting toolset
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use crate::{
    library::{array::Array, option::AnkhaOption, reflection::Function},
    script::stack_managed_variant,
};
use intuicio_core::{
    context::Context,
    registry::Registry,
    transformer::{DynamicManagedValueTransformer, ValueTransformer},
    types::struct_type::NativeStructBuilder,
};
use intuicio_derive::{intuicio_method, intuicio_methods};

pub fn install(registry: &mut Registry) {
    registry.add_type(
        NativeStructBuilder::new_named_uninitialized::<Closure>("Closure")
            .module_name("closure")
            .build(),
    );
    registry.add_function(Closure::new__define_function(registry));
    registry.add_function(Closure::from_function__define_function(registry));
    registry.add_function(Closure::call__define_function(registry));
}

pub struct Closure {
    function: Function,
    captured: Array,
}

#[intuicio_methods(module_name = "closure")]
impl Closure {
    #[intuicio_method(transformer = "DynamicManagedValueTransformer")]
    pub fn new(function: Function, captured: Array) -> Self {
        Self { function, captured }
    }

    #[intuicio_method(transformer = "DynamicManagedValueTransformer")]
    pub fn from_function(function: Function) -> Self {
        Self {
            function,
            captured: Default::default(),
        }
    }

    pub fn invoke(
        &mut self,
        context: &mut Context,
        registry: &Registry,
        arguments: Vec<AnkhaOption>,
    ) {
        for argument in arguments.into_iter().rev() {
            match argument {
                AnkhaOption::None => {
                    panic!("Cannot use none value as closure argument!");
                }
                AnkhaOption::Owned(value) => {
                    context.stack().push(value);
                }
                AnkhaOption::Ref(value) => {
                    context.stack().push(value);
                }
                AnkhaOption::RefMut(value) => {
                    context.stack().push(value);
                }
                AnkhaOption::Lazy(value) => {
                    context.stack().push(value);
                }
                AnkhaOption::Gc(value) => {
                    context.stack().push(value);
                }
            }
        }
        for argument in self.captured.inner_mut().iter_mut().rev() {
            match argument {
                AnkhaOption::None => {
                    panic!("Cannot use none value as closure capture!");
                }
                AnkhaOption::Owned(_) => {
                    panic!("Cannot use owned value as closure capture!");
                }
                AnkhaOption::Ref(value) => {
                    context
                        .stack()
                        .push(value.borrow().expect("Could not borrow ref value!"));
                }
                AnkhaOption::RefMut(value) => {
                    context.stack().push(
                        value
                            .borrow_mut()
                            .expect("Could not borrow mutably ref mut value!"),
                    );
                }
                AnkhaOption::Lazy(value) => {
                    context.stack().push(value.clone());
                }
                AnkhaOption::Gc(value) => {
                    context.stack().push(value.reference());
                }
            }
        }
        self.function.0.invoke(context, registry);
    }

    #[intuicio_method(
        use_context,
        use_registry,
        transformer = "DynamicManagedValueTransformer"
    )]
    pub fn call(
        &mut self,
        context: &mut Context,
        registry: &Registry,
        arguments: Array,
    ) -> AnkhaOption {
        self.invoke(context, registry, arguments.into_inner());
        if self.function.0.signature().outputs.len() == 1 {
            stack_managed_variant(
                context,
                |_, value| value.into(),
                |_, value| value.into(),
                |_, value| value.into(),
                |_, value| value.into(),
                |_, value| value.into(),
            )
        } else {
            AnkhaOption::None
        }
    }
}