geam-core 0.2.0

Typed Gleam planning, host, and execution core 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

use crate::HostType;
use std::marker::PhantomData;

/// A call-scoped opaque handle for one statically declared source type.
///
/// Provider macros use this type for generic source values and opaque function
/// pass-through. It does not expose the concrete runtime family or materialize
/// the represented value. Use an active [`super::Call`] for source equality,
/// hashing, and inspection.
pub struct Value<Type, Context = MissingValueContext> {
    context: Context,
    type_: PhantomData<fn() -> Type>,
}

#[doc(hidden)]
pub struct MissingValueContext;

/// The exact typed host handle inserted by provider macro expansion.
#[doc(hidden)]
pub struct ProviderValueContext<'call, Host>
where
    Host: HostType,
{
    value: Host::Value<'call>,
}

impl<'call, Type, Host> Value<Type, ProviderValueContext<'call, Host>>
where
    Host: HostType,
{
    #[doc(hidden)]
    pub fn from_host(value: Host::Value<'call>) -> Self {
        Self {
            context: ProviderValueContext { value },
            type_: PhantomData,
        }
    }

    #[doc(hidden)]
    pub fn into_host(self) -> Host::Value<'call> {
        self.context.value
    }

    pub(crate) fn host(&self) -> Host::Value<'call>
    where
        Host::Value<'call>: Clone,
    {
        self.context.value.clone()
    }
}

#[cfg(test)]
mod tests {
    use super::{ProviderValueContext, Value};
    use crate::host::{HostTypeParameter, HostValue, HostValueFamily, HostValueToken};

    #[test]
    fn provider_value_preserves_the_exact_call_scoped_host_handle() {
        type Parameter = HostTypeParameter<0>;
        let host = HostValue::<Parameter>::new(HostValueToken {
            family: HostValueFamily::String,
            index: 4,
        });
        let value = Value::<Parameter, ProviderValueContext<'_, Parameter>>::from_host(host);

        assert_eq!(value.host().token, host.token);
        assert_eq!(value.into_host().token, host.token);
    }
}