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

use crate::host::{HostCustomTypeSchema, HostExternalTypeSchema};
use crate::plan::{CustomTypeName, ExternalTypeName, FunctionType, TypeScheme};
use thiserror::Error;

#[derive(Debug, Error, Clone, PartialEq, Eq)]
pub enum ExternalTypeProviderLinkReason {
    #[error("source module is not linked")]
    MissingModule,
    #[error("external type registration is missing")]
    MissingRegistration,
    #[error("type declaration is missing")]
    MissingDeclaration,
    #[error("external storage type has source constructors")]
    ConstructorBackedType,
    #[error("external type identity mismatch: expected {expected:?}, got {actual:?}")]
    IdentityMismatch {
        expected: ExternalTypeName,
        actual: ExternalTypeName,
    },
    #[error("external type expects {expected} type arguments, but host ABI declares {actual}")]
    ParameterCount { expected: usize, actual: usize },
}

#[derive(Debug, Error, Clone, PartialEq, Eq)]
pub enum HostProviderLinkReason {
    #[error("source module is not linked")]
    MissingModule,
    #[error("function declaration is missing")]
    MissingDeclaration,
    #[error("function is not external")]
    NonExternalFunction,
    #[error(
        "function scheme mismatch: expected {expected_scheme:?} {expected_type:?}, got {actual_scheme:?} {actual_type:?}"
    )]
    SchemeMismatch {
        expected_scheme: TypeScheme,
        expected_type: FunctionType,
        actual_scheme: TypeScheme,
        actual_type: FunctionType,
    },
    #[error("custom type {custom_type:?} is missing")]
    MissingCustomType { custom_type: CustomTypeName },
    #[error("custom type {custom_type:?} is not visible to the host function")]
    CustomTypeVisibility { custom_type: CustomTypeName },
    #[error(
        "custom type {custom_type:?} expects {expected} type arguments, but host ABI applies {actual}"
    )]
    CustomTypeArgumentCount {
        custom_type: CustomTypeName,
        expected: usize,
        actual: usize,
    },
    #[error("custom schema mismatch: expected {expected:?}, got {actual:?}")]
    CustomSchemaMismatch {
        expected: HostCustomTypeSchema,
        actual: HostCustomTypeSchema,
    },
    #[error("external type {external_type:?} is missing")]
    MissingExternalType { external_type: ExternalTypeName },
    #[error(
        "external type {external_type:?} expects {expected} type arguments, but host ABI applies {actual}"
    )]
    ExternalTypeArgumentCount {
        external_type: ExternalTypeName,
        expected: usize,
        actual: usize,
    },
    #[error("external schema mismatch: expected {expected:?}, got {actual:?}")]
    ExternalSchemaMismatch {
        expected: HostExternalTypeSchema,
        actual: HostExternalTypeSchema,
    },
}