sema-stdlib 1.13.0

Standard library (350+ native functions) for the Sema programming 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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use std::collections::BTreeMap;

use regex::Regex;
use sema_core::{check_arity, SemaError, Value};

use crate::register_fn;

fn compile_regex(pattern: &str) -> Result<Regex, SemaError> {
    Regex::new(pattern).map_err(|e| {
        SemaError::eval(format!("invalid regex pattern: {e}")).with_hint(
            "Sema uses Rust regex syntax (no lookahead/lookbehind). See https://docs.rs/regex",
        )
    })
}

pub fn register(env: &sema_core::Env) {
    register_fn(env, "regex/match?", |args| {
        check_arity!(args, "regex/match?", 2);
        let pattern = args[0]
            .as_str()
            .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?;
        let text = args[1]
            .as_str()
            .ok_or_else(|| SemaError::type_error("string", args[1].type_name()))?;
        let re = compile_regex(pattern)?;
        Ok(Value::bool(re.is_match(text)))
    });

    register_fn(env, "regex/match", |args| {
        check_arity!(args, "regex/match", 2);
        let pattern = args[0]
            .as_str()
            .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?;
        let text = args[1]
            .as_str()
            .ok_or_else(|| SemaError::type_error("string", args[1].type_name()))?;
        let re = compile_regex(pattern)?;
        match re.captures(text) {
            None => Ok(Value::nil()),
            Some(caps) => {
                let full = caps.get(0).unwrap();
                let mut map = BTreeMap::new();
                map.insert(Value::keyword("match"), Value::string(full.as_str()));
                let groups: Vec<Value> = caps
                    .iter()
                    .skip(1)
                    .map(|m| match m {
                        Some(m) => Value::string(m.as_str()),
                        None => Value::nil(),
                    })
                    .collect();
                map.insert(Value::keyword("groups"), Value::list(groups));
                map.insert(Value::keyword("start"), Value::int(full.start() as i64));
                map.insert(Value::keyword("end"), Value::int(full.end() as i64));
                Ok(Value::map(map))
            }
        }
    });

    register_fn(env, "regex/find-all", |args| {
        check_arity!(args, "regex/find-all", 2);
        let pattern = args[0]
            .as_str()
            .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?;
        let text = args[1]
            .as_str()
            .ok_or_else(|| SemaError::type_error("string", args[1].type_name()))?;
        let re = compile_regex(pattern)?;
        let matches: Vec<Value> = re
            .find_iter(text)
            .map(|m| Value::string(m.as_str()))
            .collect();
        Ok(Value::list(matches))
    });

    register_fn(env, "regex/replace", |args| {
        check_arity!(args, "regex/replace", 3);
        let pattern = args[0]
            .as_str()
            .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?;
        let replacement = args[1]
            .as_str()
            .ok_or_else(|| SemaError::type_error("string", args[1].type_name()))?;
        let text = args[2]
            .as_str()
            .ok_or_else(|| SemaError::type_error("string", args[2].type_name()))?;
        let re = compile_regex(pattern)?;
        Ok(Value::string(&re.replace(text, replacement)))
    });

    register_fn(env, "regex/replace-all", |args| {
        check_arity!(args, "regex/replace-all", 3);
        let pattern = args[0]
            .as_str()
            .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?;
        let replacement = args[1]
            .as_str()
            .ok_or_else(|| SemaError::type_error("string", args[1].type_name()))?;
        let text = args[2]
            .as_str()
            .ok_or_else(|| SemaError::type_error("string", args[2].type_name()))?;
        let re = compile_regex(pattern)?;
        Ok(Value::string(&re.replace_all(text, replacement)))
    });

    register_fn(env, "regex/split", |args| {
        check_arity!(args, "regex/split", 2);
        let pattern = args[0]
            .as_str()
            .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?;
        let text = args[1]
            .as_str()
            .ok_or_else(|| SemaError::type_error("string", args[1].type_name()))?;
        let re = compile_regex(pattern)?;
        let parts: Vec<Value> = re.split(text).map(Value::string).collect();
        Ok(Value::list(parts))
    });
}