geam-core 0.2.2

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
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

use crate::plan::{CustomTypeName, FunctionType};
use ecow::EcoString;
use thiserror::Error;

/// A failure while selecting typed functions from a Gleam module.
#[derive(Debug, Error, Clone, PartialEq, Eq)]
pub enum BindingError {
    #[error("function {name} does not exist in the Gleam module")]
    MissingFunction { name: EcoString },
    #[error("function {name} is not public")]
    NonPublicFunction { name: EcoString },
    #[error("function {name} was selected more than once")]
    DuplicateFunction { name: EcoString },
    #[error("generic function {name} cannot be embedded without a concrete specialization")]
    GenericFunction { name: EcoString },
    #[error("function {name} has type {found:?}, expected {expected:?}")]
    SignatureMismatch {
        name: EcoString,
        expected: FunctionType,
        found: FunctionType,
    },
    #[error("function {name} uses {package}:{module}.{type_name} with a nonstandard definition")]
    StandardTypeMismatch {
        name: EcoString,
        package: EcoString,
        module: EcoString,
        type_name: EcoString,
    },
}

impl BindingError {
    pub(super) fn standard_type_mismatch(name: EcoString, type_: CustomTypeName) -> Self {
        Self::StandardTypeMismatch {
            name,
            package: type_.package().clone(),
            module: type_.module().clone(),
            type_name: type_.name().clone(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::BindingError;
    use crate::{FunctionType, ValueType};

    #[test]
    fn displays_each_named_binding_failure() {
        let cases = [
            (
                BindingError::MissingFunction {
                    name: "missing".into(),
                },
                "function missing does not exist in the Gleam module",
            ),
            (
                BindingError::NonPublicFunction {
                    name: "private".into(),
                },
                "function private is not public",
            ),
            (
                BindingError::DuplicateFunction {
                    name: "duplicate".into(),
                },
                "function duplicate was selected more than once",
            ),
            (
                BindingError::GenericFunction {
                    name: "identity".into(),
                },
                "generic function identity cannot be embedded without a concrete specialization",
            ),
            (
                BindingError::StandardTypeMismatch {
                    name: "optional".into(),
                    package: "gleam_stdlib".into(),
                    module: "gleam/option".into(),
                    type_name: "Option".into(),
                },
                "function optional uses gleam_stdlib:gleam/option.Option with a nonstandard definition",
            ),
        ];

        for (error, expected) in cases {
            assert_eq!(error.to_string(), expected);
            assert_eq!(error.clone(), error);
        }
    }

    #[test]
    fn displays_an_exact_signature_mismatch() {
        let expected = FunctionType::new(vec![ValueType::Int], ValueType::Int);
        let found = FunctionType::new(vec![ValueType::String], ValueType::String);
        let error = BindingError::SignatureMismatch {
            name: "convert".into(),
            expected: expected.clone(),
            found: found.clone(),
        };

        assert_eq!(
            error.to_string(),
            "function convert has type FunctionType { arguments: [String], return_: String }, expected FunctionType { arguments: [Int], return_: Int }",
        );
        assert_eq!(
            error,
            BindingError::SignatureMismatch {
                name: "convert".into(),
                expected,
                found,
            },
        );
    }
}