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

use crate::host::HostParameter;
use crate::plan::{FunctionTemplateId, FunctionTemplateSignature, FunctionType, TypeScheme};
use ecow::EcoString;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HostFunctionTemplate {
    signature: FunctionTemplateSignature,
    package: EcoString,
    site: crate::plan::HostCallSite,
    layout: Box<[HostParameter]>,
    parameters: Box<[crate::host::HostTypeDescriptor]>,
    return_: crate::host::HostTypeDescriptor,
    custom_schemas: Box<[crate::host::HostCustomTypeSchema]>,
    external_schemas: Box<[crate::host::HostExternalTypeSchema]>,
    type_: FunctionType,
}

impl HostFunctionTemplate {
    pub(crate) fn from_schema(
        signature: FunctionTemplateSignature,
        package: EcoString,
        site: crate::plan::HostCallSite,
        schema: crate::host::HostFunctionSchema,
    ) -> Self {
        Self {
            signature,
            package,
            site,
            layout: schema.layout().to_vec().into_boxed_slice(),
            parameters: schema.parameters().to_vec().into_boxed_slice(),
            return_: schema.return_type().clone(),
            custom_schemas: schema.custom_schemas().to_vec().into_boxed_slice(),
            external_schemas: schema.external_schemas().to_vec().into_boxed_slice(),
            type_: schema.type_().clone(),
        }
    }

    pub fn id(&self) -> FunctionTemplateId {
        self.signature.id()
    }

    pub fn package(&self) -> &EcoString {
        &self.package
    }

    pub fn module(&self) -> &EcoString {
        self.site.module()
    }

    pub fn name(&self) -> &EcoString {
        self.site.function()
    }

    pub(crate) fn site(&self) -> &crate::plan::HostCallSite {
        &self.site
    }

    pub(crate) fn layout(&self) -> &[HostParameter] {
        &self.layout
    }

    pub(crate) fn parameters(&self) -> &[crate::host::HostTypeDescriptor] {
        &self.parameters
    }

    pub(crate) fn return_type(&self) -> &crate::host::HostTypeDescriptor {
        &self.return_
    }

    pub(crate) fn custom_schemas(&self) -> &[crate::host::HostCustomTypeSchema] {
        &self.custom_schemas
    }

    pub(crate) fn external_schemas(&self) -> &[crate::host::HostExternalTypeSchema] {
        &self.external_schemas
    }

    pub fn scheme(&self) -> &TypeScheme {
        self.signature.scheme()
    }

    pub fn type_(&self) -> &FunctionType {
        &self.type_
    }

    pub(crate) fn signature(&self) -> &FunctionTemplateSignature {
        &self.signature
    }
}