valkyrie-errors 0.0.3

Error types for valkyrie language
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

use std::{
    collections::hash_map::DefaultHasher,
    hash::{Hash, Hasher},
    ops::Not,
    sync::Arc,
};

use indexmap::IndexMap;

use crate::{types::ValkyrieMetaType, ValkyrieTypeLegacy, ValkyrieValue};

impl ValkyrieTypeLegacy for bool {
    fn boxed(self) -> ValkyrieValue {
        ValkyrieValue::Boolean(self)
    }

    fn type_info(&self) -> Arc<ValkyrieMetaType> {
        let mut meta = ValkyrieMetaType::default();
        meta.set_namepath("std.primitive.Boolean");
        Arc::new(meta)
    }
}

pub struct TypeManager {
    types: IndexMap<u64, Arc<ValkyrieMetaType>>,
}

impl TypeManager {
    pub fn get_or_insert(&mut self, info: Arc<ValkyrieMetaType>) -> Arc<ValkyrieMetaType> {
        let mut hasher = DefaultHasher::new();
        info.hash(&mut hasher);
        let hash = hasher.finish();
        match self.types.get(&hash) {
            Some(t) => t.clone(),
            None => {
                self.types.insert(hash, info.clone());
                info
            }
        }
    }
}

pub struct ValkyrieFunction {
    document: String,
    parameters: Vec<ValkyrieMetaType>,
    return_type: ValkyrieMetaType,
    function_ptr: ValkyrieFunctionInstance,
}

pub enum ValkyrieFunctionInstance {
    Normal { apply: fn(Vec<ValkyrieValue>) -> ValkyrieValue },
    Curry { apply: fn(Vec<ValkyrieValue>) -> ValkyrieValue, parameters: Vec<ValkyrieValue> },
}

impl From<bool> for ValkyrieValue {
    fn from(value: bool) -> Self {
        ValkyrieValue::Boolean(value)
    }
}

// std.primitive.Boolean
pub fn not(args: Vec<ValkyrieValue>, kws: IndexMap<String, ValkyrieValue>) -> ValkyrieValue {
    if !kws.is_empty() {
        panic!("Invalid keyword arguments");
    }
    match args.get(0) {
        Some(ValkyrieValue::Boolean(p)) => return ValkyrieValue::from(p.not()),
        _ => panic!("Invalid type"),
    }
}

pub fn and(p: bool, q: bool) -> bool {
    p && q
}

pub fn or(p: bool, q: bool) -> bool {
    p || q
}

pub fn logic_gate(p: bool, q: bool, mask: u8) -> Result<bool, String> {
    let ok = match mask {
        0 => false,
        1 => p && q,
        2 => p && !q,
        3 => p,
        4 => !p && q,
        5 => q,
        6 => p ^ q,
        7 => p || q,
        8 => !p && !q,
        9 => p == q,
        10 => !q,
        11 => p || !q,
        12 => !p,
        13 => !p || q,
        14 => !p || !q,
        15 => true,
        _ => return Err(format!("Invalid mask: {}", mask)),
    };
    Ok(ok)
}