geam-stdlib 0.2.0

Official Gleam standard-library providers for Geam
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

mod function;
mod parse;

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

use super::{Component, GleamStdlibHostProfile, GleamStdlibRunState};
use crate::{HostProviderModule, HostRegistrationError};
use ecow::EcoString;
use geam_core::provider::{Call, HostResult};
use num_bigint::BigInt;

#[geam_macros::module(
    path = "gleam/float",
    crate_path = geam_core,
    profile = crate::GleamStdlibHostProfile,
    component = crate::Component<Profile::Io>,
)]
mod provider {
    use super::{BigInt, Call, EcoString, GleamStdlibRunState, HostResult, function};

    #[geam_macros::function]
    fn parse(source: EcoString) -> Result<f64, ()> {
        function::parse(source)
    }

    #[geam_macros::function]
    fn to_string(value: f64) -> EcoString {
        function::to_string(value)
    }

    #[geam_macros::function]
    fn ceiling(value: f64) -> f64 {
        function::ceiling(value)
    }

    #[geam_macros::function]
    fn floor(value: f64) -> f64 {
        function::floor(value)
    }

    #[geam_macros::function]
    fn js_round(value: f64) -> HostResult<BigInt> {
        function::js_round(value).map_err(Into::into)
    }

    #[geam_macros::function]
    fn truncate(value: f64) -> HostResult<BigInt> {
        function::truncate(value).map_err(Into::into)
    }

    #[geam_macros::function]
    fn do_to_float(value: BigInt) -> HostResult<f64> {
        function::do_to_float(value).map_err(Into::into)
    }

    #[geam_macros::function]
    fn do_power(base: f64, exponent: f64) -> f64 {
        function::do_power(base, exponent)
    }

    #[geam_macros::function(profile = Profile)]
    fn random(#[geam_macros::call] call: &mut Call<GleamStdlibRunState<Profile::Io>>) -> f64 {
        call.state_mut().random_float()
    }

    #[geam_macros::function]
    fn do_log(value: f64) -> f64 {
        function::do_log(value)
    }

    #[geam_macros::function]
    fn exponential(value: f64) -> f64 {
        function::exponential(value)
    }
}

pub(super) fn host_provider<Profile>() -> Result<HostProviderModule<Profile>, HostRegistrationError>
where
    Profile: GleamStdlibHostProfile,
{
    provider::__geam_module::<Profile>()
}

#[cfg(test)]
mod tests {
    use super::host_provider;
    use crate::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",
            ],
        );
    }
}