geam 0.1.1

Experimental Rust-embedded execution runtime for typed Gleam programs
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

mod function;
mod parse;
mod schema;

pub(super) use self::function::do_to_float;

use self::function::{
    FloatProvider, ceiling, do_log, do_power, exponential, floor, js_round, parse, random,
    to_string, truncate,
};
use self::schema::ParseResult;
use super::GleamStdlibHostProfile;
use crate::{HostProviderModule, HostRegistrationError};
use ecow::EcoString;
use num_bigint::BigInt;

pub(super) fn host_provider<Profile>() -> Result<HostProviderModule<Profile>, HostRegistrationError>
where
    Profile: GleamStdlibHostProfile,
{
    HostProviderModule::new("gleam_stdlib", "gleam/float")
        .and_then(|provider| {
            provider.with_scoped_function::<FloatProvider<Profile>, (EcoString,), ParseResult, _>(
                "parse",
                parse::<Profile>,
            )
        })
        .and_then(|provider| provider.with_function("to_string", to_string))
        .and_then(|provider| provider.with_function("ceiling", ceiling))
        .and_then(|provider| provider.with_function("floor", floor))
        .and_then(|provider| {
            provider.with_fallible_function::<(f64,), BigInt, _>("js_round", js_round)
        })
        .and_then(|provider| {
            provider.with_fallible_function::<(f64,), BigInt, _>("truncate", truncate)
        })
        .and_then(|provider| {
            provider.with_fallible_function::<(BigInt,), f64, _>("do_to_float", do_to_float)
        })
        .and_then(|provider| provider.with_function("do_power", do_power))
        .and_then(|provider| {
            provider.with_scoped_function::<FloatProvider<Profile>, (), f64, _>(
                "random",
                random::<Profile>,
            )
        })
        .and_then(|provider| provider.with_function("do_log", do_log))
        .and_then(|provider| provider.with_function("exponential", exponential))
}

#[cfg(test)]
mod tests {
    use super::host_provider;
    use crate::gleam_stdlib::GleamStdlibProfile;

    #[test]
    fn registers_the_exact_official_float_provider_inventory() {
        let provider =
            host_provider::<GleamStdlibProfile>().expect("official float provider should register");

        assert_eq!(provider.package(), "gleam_stdlib");
        assert_eq!(provider.module(), "gleam/float");
        assert_eq!(
            provider
                .functions()
                .map(|function| function.name().as_str())
                .collect::<Vec<_>>(),
            [
                "parse",
                "to_string",
                "ceiling",
                "floor",
                "js_round",
                "truncate",
                "do_to_float",
                "do_power",
                "random",
                "do_log",
                "exponential",
            ],
        );
    }
}