gluon 0.18.2

A static, type inferred programming language for application embedding
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
129
130
131
132

#![allow(dead_code)]

pub extern crate futures;

use gluon::{
    import::Import,
    vm::{
        api::{Getable, VmType},
        thread::{RootedThread, Thread},
    },
    ThreadExt,
};

#[allow(dead_code)]
pub fn load_script(vm: &Thread, filename: &str, input: &str) -> ::gluon::Result<()> {
    vm.get_database_mut().set_implicit_prelude(false);
    vm.load_script(filename, input)
}

#[allow(dead_code)]
pub fn run_expr_<'vm, T>(vm: &'vm Thread, s: &str, implicit_prelude: bool) -> T
where
    T: for<'value> Getable<'vm, 'value> + VmType + Send + 'vm,
{
    vm.get_database_mut()
        .implicit_prelude(implicit_prelude)
        .run_io(true);
    vm.run_expr("<top>", s)
        .unwrap_or_else(|err| panic!("{}", err))
        .0
}

#[allow(dead_code)]
pub fn run_expr<'vm, T>(vm: &'vm Thread, s: &str) -> T
where
    T: for<'value> Getable<'vm, 'value> + VmType + Send + 'vm,
{
    run_expr_(vm, s, false)
}

/// Creates a VM for testing which has the correct paths to import the std library properly
pub fn make_vm() -> RootedThread {
    let vm = ::gluon::VmBuilder::new().build();
    let import = vm.get_macros().get("import");
    import
        .as_ref()
        .and_then(|import| import.downcast_ref::<Import>())
        .expect("Import macro")
        .add_path("..");
    vm
}

pub async fn make_vm_async() -> RootedThread {
    let vm = ::gluon::VmBuilder::new().build_async().await;
    let import = vm.get_macros().get("import");
    import
        .as_ref()
        .and_then(|import| import.downcast_ref::<Import>())
        .expect("Import macro")
        .add_path("..");
    vm
}

#[allow(unused_macros)]
macro_rules! test_expr {
    (prelude $name:ident, $expr:expr, $value:expr) => {
        #[test]
        fn $name() {
            let _ = ::env_logger::try_init();
            let mut vm = $crate::support::make_vm();
            let value = $crate::support::run_expr_(&mut vm, $expr, true);
            assert_eq!(value, $value);

            // Help out the type inference by forcing that left and right are the same types
            fn equiv<T>(_: &T, _: &T) {}
            equiv(&value, &$value);
        }
    };
    (io $name:ident, $expr:expr, $value:expr) => {
        #[test]
        fn $name() {
            use gluon::{vm::api::IO, ThreadExt};

            let _ = ::env_logger::try_init();
            let vm = $crate::support::make_vm();
            vm.get_database_mut().implicit_prelude(false).run_io(true);
            let (value, _) = vm
                .run_expr("<top>", $expr)
                .unwrap_or_else(|err| panic!("{}", err));
            match value {
                IO::Value(value) => {
                    assert_eq!(value, $value);

                    // Help out the type inference by forcing that left and right are the same types
                    fn equiv<T>(_: &T, _: &T) {}
                    equiv(&value, &$value);
                }
                IO::Exception(err) => panic!("{}", err),
            }
        }
    };
    (any $name:ident, $expr:expr, $value:expr) => {
        #[test]
        fn $name() {
            let _ = ::env_logger::try_init();
            let mut vm = $crate::support::make_vm();
            let value = $crate::support::run_expr::<OpaqueValue<&Thread, Hole>>(&mut vm, $expr);
            assert_eq!(value.get_ref(), $value);
        }
    };
    ($name:ident, $expr:expr, $value:expr) => {
        #[test]
        fn $name() {
            let _ = ::env_logger::try_init();
            let mut vm = $crate::support::make_vm();
            let value = $crate::support::run_expr(&mut vm, $expr);
            assert_eq!(value, $value);

            // Help out the type inference by forcing that left and right are the same types
            fn equiv<T>(_: &T, _: &T) {}
            equiv(&value, &$value);
        }
    };
    ($name:ident, $expr:expr) => {
        #[test]
        fn $name() {
            let _ = ::env_logger::try_init();
            let mut vm = $crate::support::make_vm();
            $crate::support::run_expr::<OpaqueValue<&Thread, Hole>>(&mut vm, $expr);
        }
    };
}