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
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use super::{IoOutput, IoSink, IoStream};
use crate::gleam_stdlib::GleamStdlibHostProfile;
use crate::{HostCall, HostCallCompletion, HostCallError, HostProvider};
use ecow::EcoString;
use std::marker::PhantomData;

pub(super) struct IoProvider<Profile>(PhantomData<Profile>);

impl<Profile> HostProvider<Profile> for IoProvider<Profile>
where
    Profile: GleamStdlibHostProfile,
{
    type State = Profile::Io;

    fn project(state: &mut Profile::RunState) -> &mut Self::State {
        Profile::gleam_stdlib_io(state)
    }
}

pub(super) fn print<'call, Profile>(
    call: HostCall<'call, Profile, IoProvider<Profile>, ()>,
    text: EcoString,
) -> Result<HostCallCompletion<'call, ()>, HostCallError>
where
    Profile: GleamStdlibHostProfile,
{
    emit(call, IoStream::Stdout, text)
}

pub(super) fn print_error<'call, Profile>(
    call: HostCall<'call, Profile, IoProvider<Profile>, ()>,
    text: EcoString,
) -> Result<HostCallCompletion<'call, ()>, HostCallError>
where
    Profile: GleamStdlibHostProfile,
{
    emit(call, IoStream::Stderr, text)
}

pub(super) fn println<'call, Profile>(
    call: HostCall<'call, Profile, IoProvider<Profile>, ()>,
    mut text: EcoString,
) -> Result<HostCallCompletion<'call, ()>, HostCallError>
where
    Profile: GleamStdlibHostProfile,
{
    text.push('\n');
    emit(call, IoStream::Stdout, text)
}

pub(super) fn println_error<'call, Profile>(
    call: HostCall<'call, Profile, IoProvider<Profile>, ()>,
    mut text: EcoString,
) -> Result<HostCallCompletion<'call, ()>, HostCallError>
where
    Profile: GleamStdlibHostProfile,
{
    text.push('\n');
    emit(call, IoStream::Stderr, text)
}

fn emit<'call, Profile>(
    mut call: HostCall<'call, Profile, IoProvider<Profile>, ()>,
    stream: IoStream,
    text: EcoString,
) -> Result<HostCallCompletion<'call, ()>, HostCallError>
where
    Profile: GleamStdlibHostProfile,
{
    call.state().emit(IoOutput::new(stream, text));
    Ok(call.return_value(()))
}

#[cfg(test)]
mod tests {
    use crate::gleam_stdlib::{GleamStdlibProfile, GleamStdlibRunState, IoStream};
    use crate::{
        HostModule, HostProviderSet, HostedExecution, ModuleSource, PackageSource, Value,
        compile_typed_host_program, plan_host_program,
    };
    use ecow::EcoString;

    const IO_SOURCE: &str = r#"
@external(erlang, "gleam_stdlib", "print")
pub fn print(string: String) -> Nil

@external(erlang, "gleam_stdlib", "print_error")
pub fn print_error(string: String) -> Nil

@external(erlang, "gleam_stdlib", "println")
pub fn println(string: String) -> Nil

@external(erlang, "gleam_stdlib", "println_error")
pub fn println_error(string: String) -> Nil

pub fn main() {
  print("first")
  print_error("second")
  println("third")
  println_error("fourth")
}
"#;

    #[test]
    fn executes_all_io_callbacks_through_the_typed_provider() {
        let provider = super::super::host_provider::<GleamStdlibProfile>()
            .expect("synthetic IO provider should register");
        let typed = compile_typed_host_program(
            "gleam_stdlib",
            "gleam/io",
            [PackageSource::new(
                "gleam_stdlib",
                Vec::<EcoString>::new(),
                [ModuleSource::new(
                    "gleam/io",
                    "src/gleam/io.gleam",
                    IO_SOURCE,
                )],
            )],
            HostProviderSet::with_providers(
                Vec::<HostModule<GleamStdlibProfile>>::new(),
                [provider],
            )
            .expect("synthetic IO provider module should be unique"),
        )
        .expect("synthetic IO source should compile");
        let plan = plan_host_program(typed).expect("synthetic IO source should plan");
        let execution =
            HostedExecution::try_from_module_plan(plan).expect("synthetic IO source should seal");
        let mut state = GleamStdlibRunState::from_seed([2; 32]);

        assert_eq!(
            execution
                .run_main(&mut state, &mut Vec::new())
                .expect("synthetic IO source should run"),
            Value::Nil,
        );
        assert_eq!(
            state
                .io_outputs()
                .iter()
                .map(|output| (output.stream(), output.text().as_str()))
                .collect::<Vec<_>>(),
            [
                (IoStream::Stdout, "first"),
                (IoStream::Stderr, "second"),
                (IoStream::Stdout, "third\n"),
                (IoStream::Stderr, "fourth\n"),
            ],
        );
    }
}