mica 0.7.1

A simple, user-friendly, embeddable scripting 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

use std::ops::Deref;

use crate::{
    corelib::iterators::string::{
        bytes::StringBytes, chars::StringChars, code_points::StringCodePoints, lines::StringLines,
        rsplit::StringRSplit, split::StringSplit,
    },
    ll::gc::Gc,
    Arguments, IntoValue, MethodParameterCount, MicaLanguageResultExt, RawFunctionKind,
    TypeBuilder,
};

pub(crate) fn define(builder: TypeBuilder<String>) -> TypeBuilder<String> {
    builder
        .add_function("cat", |s: &String, t: Gc<String>| format!("{s}{t}"))
        .add_function("contains", |s: &String, sub: Gc<String>| s.contains(sub.deref().deref()))
        .add_function("starts_with", |s: &String, prefix: Gc<String>| {
            s.starts_with(prefix.deref().deref())
        })
        .add_function("ends_with", |s: &String, suffix: Gc<String>| {
            s.ends_with(suffix.deref().deref())
        })
        .add_function("strip_prefix", |s: &String, prefix: Gc<String>| {
            s.strip_prefix(prefix.deref().deref()).map(|x| x.to_owned())
        })
        .add_function("strip_suffix", |s: &String, suffix: Gc<String>| {
            s.strip_suffix(suffix.deref().deref()).map(|x| x.to_owned())
        })
        .add_function("find", |s: &String, substr: Gc<String>| s.find(substr.deref().deref()))
        .add_function("rfind", |s: &String, substr: Gc<String>| s.rfind(substr.deref().deref()))
        .add_function("byte_at", |s: &String, position: usize| s.as_bytes().get(position).copied())
        .add_function("byte_len", |s: &String| s.len())
        .add_function("nth_char", |s: &String, position: usize| s.chars().nth(position))
        .add_function("nth_code_point", |s: &String, position: usize| {
            s.chars().nth(position).map(u32::from)
        })
        .add_function("char_len", |s: &String| s.chars().count())
        .add_function("is_empty", |s: &String| s.is_empty())
        .add_function("to_lowercase", |s: &String| s.to_lowercase())
        .add_function("to_uppercase", |s: &String| s.to_uppercase())
        .add_function("repeat", |s: &String, n: usize| s.repeat(n))
        .add_function("replace", |s: &String, pat: Gc<String>, with: Gc<String>| {
            s.replace(pat.deref().deref(), &with)
        })
        .add_function("replace", |s: &String, pat: Gc<String>, with: Gc<String>, n: usize| {
            s.replacen(pat.deref().deref(), &with, n)
        })
        .add_function("trim", |s: &String| s.trim().to_owned())
        // TODO: It should be possible to implement these without raw functions in the future.
        .add_raw_function(
            "bytes",
            MethodParameterCount::from_count_with_self(1),
            RawFunctionKind::Foreign(Box::new(|env, gc, args| {
                let arguments = Arguments::new(args, env);
                let iter = unsafe { StringBytes::new(*arguments.raw_self()) };
                Ok(iter.into_value_with_environment(env).to_raw(gc))
            })),
        )
        .add_raw_function(
            "chars",
            MethodParameterCount::from_count_with_self(1),
            RawFunctionKind::Foreign(Box::new(|env, gc, args| {
                let arguments = Arguments::new(args, env);
                let iter = unsafe { StringChars::new(*arguments.raw_self()) };
                Ok(iter.into_value_with_environment(env).to_raw(gc))
            })),
        )
        .add_raw_function(
            "code_points",
            MethodParameterCount::from_count_with_self(1),
            RawFunctionKind::Foreign(Box::new(|env, gc, args| {
                let arguments = Arguments::new(args, env);
                let iter = unsafe { StringCodePoints::new(*arguments.raw_self()) };
                Ok(iter.into_value_with_environment(env).to_raw(gc))
            })),
        )
        .add_raw_function(
            "lines",
            MethodParameterCount::from_count_with_self(1),
            RawFunctionKind::Foreign(Box::new(|env, gc, args| {
                let arguments = Arguments::new(args, env);
                let iter = unsafe { StringLines::new(*arguments.raw_self()) };
                Ok(iter.into_value_with_environment(env).to_raw(gc))
            })),
        )
        .add_raw_function(
            "split",
            MethodParameterCount::from_count_with_self(2),
            RawFunctionKind::Foreign(Box::new(|env, gc, args| {
                let arguments = Arguments::new(args, env);
                let sep: Gc<String> = arguments.get(0).to_language_error()?;
                let iter = unsafe { StringSplit::new(*arguments.raw_self(), sep) };
                Ok(iter.into_value_with_environment(env).to_raw(gc))
            })),
        )
        .add_raw_function(
            "rsplit",
            MethodParameterCount::from_count_with_self(2),
            RawFunctionKind::Foreign(Box::new(|env, gc, args| {
                let arguments = Arguments::new(args, env);
                let sep: Gc<String> = arguments.get(0).to_language_error()?;
                let iter = unsafe { StringRSplit::new(*arguments.raw_self(), sep) };
                Ok(iter.into_value_with_environment(env).to_raw(gc))
            })),
        )
}