geam-stdlib 0.2.0

Official Gleam standard-library providers 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
115
116
117
118
119
120
121
122
123

use crate::dict::DictDeclaration;
use geam_core::provider::advanced::{DynamicKind, StoredDynamic};

pub(super) enum DynamicValue {
    Stored {
        representation: DynamicRepresentation,
        value: StoredDynamic<super::function::provider::DynamicPayload>,
    },
    Array {
        value: StoredDynamic<super::function::provider::DynamicPayload>,
        elements: Box<[StoredDynamic<super::function::provider::DynamicPayload>]>,
    },
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum DynamicRepresentation {
    Bool,
    String,
    Float,
    Int,
    BitArray,
    UtfCodepoint,
    List,
    Array,
    Dict,
    Nil,
    Function,
    Custom,
    External,
}

impl DynamicRepresentation {
    pub(super) fn from_value(
        value: &StoredDynamic<super::function::provider::DynamicPayload>,
    ) -> Self {
        if value.is_external::<DictDeclaration<(), ()>>() {
            return Self::Dict;
        }

        match value.kind() {
            DynamicKind::Int => Self::Int,
            DynamicKind::Float => Self::Float,
            DynamicKind::String => Self::String,
            DynamicKind::BitArray => Self::BitArray,
            DynamicKind::UtfCodepoint => Self::UtfCodepoint,
            DynamicKind::Bool => Self::Bool,
            DynamicKind::Nil => Self::Nil,
            DynamicKind::List => Self::List,
            DynamicKind::Tuple => Self::Array,
            DynamicKind::Custom => Self::Custom,
            DynamicKind::External => Self::External,
            DynamicKind::Function => Self::Function,
        }
    }

    pub(crate) fn name(self) -> &'static str {
        match self {
            Self::Bool => "Bool",
            Self::String => "String",
            Self::Float => "Float",
            Self::Int => "Int",
            Self::BitArray => "BitArray",
            Self::UtfCodepoint => "UtfCodepoint",
            Self::List => "List",
            Self::Array => "Array",
            Self::Dict => "Dict",
            Self::Nil => "Nil",
            Self::Function => "Function",
            Self::Custom => "Custom",
            Self::External => "External",
        }
    }
}

impl DynamicValue {
    pub(super) fn stored(value: StoredDynamic<super::function::provider::DynamicPayload>) -> Self {
        Self::Stored {
            representation: DynamicRepresentation::from_value(&value),
            value,
        }
    }

    pub(super) fn representation(&self) -> DynamicRepresentation {
        match self {
            Self::Stored { representation, .. } => *representation,
            Self::Array { .. } => DynamicRepresentation::Array,
        }
    }

    pub(super) fn value(&self) -> &StoredDynamic<super::function::provider::DynamicPayload> {
        match self {
            Self::Stored { value, .. } | Self::Array { value, .. } => value,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::DynamicRepresentation;

    #[test]
    fn representation_names_cover_every_source_classification() {
        let cases = [
            (DynamicRepresentation::Bool, "Bool"),
            (DynamicRepresentation::String, "String"),
            (DynamicRepresentation::Float, "Float"),
            (DynamicRepresentation::Int, "Int"),
            (DynamicRepresentation::BitArray, "BitArray"),
            (DynamicRepresentation::UtfCodepoint, "UtfCodepoint"),
            (DynamicRepresentation::List, "List"),
            (DynamicRepresentation::Array, "Array"),
            (DynamicRepresentation::Dict, "Dict"),
            (DynamicRepresentation::Nil, "Nil"),
            (DynamicRepresentation::Function, "Function"),
            (DynamicRepresentation::Custom, "Custom"),
            (DynamicRepresentation::External, "External"),
        ];

        for (representation, expected) in cases {
            assert_eq!(representation.name(), expected);
        }
    }
}